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

The annotations already declare destructive=true, openWorld=true, idempotent=false and readOnly=false, so the safety risk is visible. The description adds nothing: it does not say the adoption is irreversible, does not list rate limits or the need for device-limit bypass (ignoreDeviceLimit), and does not explain what the preview returns when confirm is omitted.

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

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

The description is very short and has a clear lead-in, so it is not verbose. However, one of its two clauses is only a documentation-source pointer, which does not help an agent decide whether or how to call 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?

This is a destructive mutation with no output schema and no information about prerequisites or post-conditions. A complete definition would cover what 'adopt' does to the device record, the pending-device requirement, and the preview behavior; instead, it defers entirely to an external docs URL.

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

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

Schema description coverage is 100%, so the schema already explains body, confirm and dry_run clearly. The description adds no parameter meaning, which is acceptable given full 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 phrase 'Adopt Devices' gives a clear verb and resource, which is more than many generated stubs. However, it does not distinguish this tool from the sibling unifi_net_adopt_devices, which appears to do the same job, nor does it identify what state a device must be in (e.g., pending) before adoption.

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 contains no guidance about when to use this tool instead of unifi_net_adopt_devices or unifi_net_device_action, and no mention of the prerequisites involved in adopting a device. The only usage hints (the confirm field 'YES' and dry_run preview) appear in the schema, not 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?

Annotations already flag this as destructive, non-idempotent and open-world, so the safety profile is known. The description adds nothing beyond that — it does not surface the confirm/dry_run gating, ordering/index side effects, or what happens to existing rules, all of which are meaningful for a destructive create.

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?

Single short sentence with zero padding, which is good, but it is under-specified rather than concise in a useful sense; the doc-page attribution consumes half the description's limited real estate.

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 create operation with no output schema, the description should at least note that a confirm token is required to actually apply, that unconfirmed calls preview, and that rule order/index matters. None of that is present, leaving an agent to discover it only from the schema.

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

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

Schema description coverage is 100% and the schema documents body/confirm/dry_run including the 'YES to apply' preview semantics. The description contributes no parameter meaning of its own, so baseline 3 applies.

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

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

The description says 'Create ACL Rule', which gives a verb and resource, but it is essentially a restatement of the tool name plus a vendor doc URL. It does nothing to distinguish this tool from siblings such as unifi_net_create_acl_rule or unifi_gen_createfirewallpolicy, and never clarifies how an ACL rule differs from a firewall policy/zone.

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 among the many create_* siblings. The only extra content is a documentation link, which is 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?

Annotations already declare destructiveHint=true, openWorldHint=true, idempotentHint=false and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: no statement of what gets created where, whether duplicates are possible, whether changes are reversible, or what the confirmation requirement means in practice.

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

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

One sentence, front-loaded with the verb, with no padding — but that brevity comes from omission rather than discipline. The dev-docs URL is a minor provenance aid that earns little space for an agent.

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

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

This is a destructive, non-idempotent creation call whose safety and preview/confirm mechanics are fully specified in annotations and parameter descriptions. The ancillary schema, notably the anyOf that permits an empty object for body, is unusual, but it is largely self-documenting at the parameter level, so the description does not need to re-explain return values or body structure here.

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% — body, confirm (const "YES") and dry_run all carry their own descriptions — so the schema does the heavy lifting and baseline 3 applies. The description contributes no additional meaning, and notably does not explain the type-dependent nature of the body fields (ipAddress vs ipv6Address vs mailServerDomain per record type).

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

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

The description names a specific verb+resource ("Create DNS Policy"), so an agent knows what it does. But it does not distinguish this tool from the near-identical sibling unifi_net_create_dns_policy, nor does it explain what a DNS policy covers versus firewall/traffic-list siblings. The trailing provenance URL is metadata, not clarification.

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 unifi_net_create_dns_policy, nor any mention of prerequisites such as site selection or the required record-type fields. The preview/confirm workflow is only implied, and only by the parameter schema, not by 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?

Annotations already declare that this is a non-read-only, open-world, non-idempotent, destructive mutation. The description adds no behavioral detail beyond the title, such as what policy scope is affected, what confirmation/preview behavior is exposed via the schema, or why a creation tool is marked destructive.

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

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

The description is a single front-loaded sentence with no padding. It is concise, though the provenance phrase does not add much operational 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 firewall-policy creation tool with a nested vendor body, the definition is too sparse. The schema and annotations cover structure and safety hints, but the description does not explain usage context, sibling choice, or mutation consequences.

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

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

Schema description coverage is 100%, so the schema already documents the body, confirm, and dry_run parameters. The description adds no parameter-specific meaning beyond pointing to the generated vendor source, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: "Create Firewall Policy." It is clear what the tool does, but it does not distinguish this generated variant from the sibling unifi_net_create_firewall_policy tool or explain that they are duplicate/related creation paths.

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 alternatives. An agent must infer that this is for creating rather than updating, patching, or deleting firewall policies, and must also infer which sibling create tool to use.

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 already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds only a vendor documentation URL and does not explain permissions required, the effect of creating a zone, or how confirm/dry_run alter behavior beyond what the schema already states.

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

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

The description is a single front-loaded sentence with no wasted prose. It is appropriately sized, though extremely terse for a destructive creation 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?

Given a destructive firewall-zone creation tool with rich annotations and a fully documented schema, the description covers the basic action and points to vendor docs. It still omits sibling differentiation and any operational context about what a firewall zone is or when this generated variant should be chosen.

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

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

Schema description coverage is 100%, so the schema already documents the body, confirm, and dry_run parameters in detail. The tool description itself adds no parameter meaning beyond the high-coverage schema, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource: “Create Custom Firewall Zone.” It is clear what operation is performed, but it does not distinguish this tool from sibling firewall-zone creation tools such as unifi_net_create_firewall_zone or explain its generated-API nature beyond the URL.

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

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

The description provides no guidance on when to use this tool versus the many sibling firewall-zone tools. It does not mention prerequisites, alternatives, or the distinction between generated and non-generated API tools.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the danger profile is known. The description adds nothing beyond that — no note about prerequisites such as an existing site, VLAN availability, or that duplicate creation is non-idempotent.

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

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

One short line with no bloat, but that brevity is under-specification rather than economy. The only content beyond the name is a vendor documentation URL, which is marginally useful but not front-loaded 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?

This is a destructive, open-world create operation with a large nested body schema and no output schema. Given that complexity, the description should say what is being created, what the confirm gate implies, and how it relates to unifi_net_create_network; it says none of that.

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

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

Schema description coverage is 100%: the body payload, its required fields (name, vlanId, enabled, management), the confirm gate, and dry_run are all documented in the schema. The description contributes no additional parameter meaning, so the baseline of 3 applies.

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

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

The description names a verb and resource ("Create Network"), which is intelligible, but it essentially restates the tool name and adds only a provenance URL. It gives no indication of what a network object is or which of the near-identical siblings (unifi_net_create_network, unifi_gen_updatenetwork) it should be preferred over.

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 the confirm/dry_run preview workflow that governs whether the call actually mutates anything. The agent must infer usage entirely from the tool name.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: no note that without confirm="YES" nothing is applied, no statement about reversibility or required permissions, which is the exact context a create-with-destroy semantics tool needs.

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, which is good, but the only content beyond the tool name is the "generated from developer.ui.com/..." provenance string, which is boilerplate rather than agent-useful information. Space that could carry the confirm/dry_run contract is spent on a docs URL.

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 destructive, non-idempotent write with no output schema and a preview-versus-apply gate in the schema. The description omits the single most important operational fact — that the call is inert unless confirm is set to "YES" — and gives no indication of what the returned preview or created object looks like.

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

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

Schema description coverage is 100% and every parameter (body, confirm, dry_run) is documented in the schema itself, so the baseline of 3 applies. The description contributes no additional meaning about the body shape, the three allowed `type` enum values, or how `items` is interpreted.

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 and resource ("Create Traffic Matching List"), so the basic action is recognizable. But the second half is only a provenance URL, and it never distinguishes this from the near-identical sibling unifi_net_create_traffic_list or from unifi_gen_updatetrafficmatchinglist, leaving the agent to guess which family to use.

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, when-not-to-use, or alternative is stated. The schema exposes a confirm/dry_run preview flow, but the description never tells the agent when a preview is appropriate versus when to apply, and never mentions the parallel unifi_net traffic-list tools.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the description must add context such as what a voucher is for, whether creation is reversible, or the confirm/preview safety flow. It adds only a docs link, leaving the destructive write behavior entirely to the annotations.

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 with the verb+resource, but the second half is a provenance note rather than information an agent can act on. Concise, yet thin rather than 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?

This is a destructive, non-idempotent creation tool with no output schema, and the description supplies none of the missing context — no return value expectations, no effect of creating multiple vouchers via count, no explanation of the preview/confirm flow. An agent cannot confidently select or call it 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 100%, so the schema already documents body fields, the confirm token, and dry_run. The description adds no parameter meaning beyond that, which is the expected baseline when the schema does the work.

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

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

"Generate Vouchers" names a verb and resource, so the basic intent is clear, but it is essentially a restatement of the tool name plus a docs URL. It does nothing to distinguish this from sibling unifi_net_create_vouchers, which appears to do the same thing.

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: no mention of when to pick this over unifi_net_create_vouchers or unifi_net_list_vouchers, and no prerequisites. The only routing hint is a URL to external vendor documentation.

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 already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: no note about what a failed create leaves behind, whether duplicate SSIDs are allowed, or what the confirm/dry_run preview returns.

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

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

It is a single short line with no bloat, but half of it is a vendor-docs URL rather than usable guidance. Brevity here reflects under-specification rather than disciplined editing.

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

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

This is a destructive create with a 25+ field body schema full of opaque nested objects (securityConfiguration, multicastFilteringPolicy, hotspotConfiguration) typed only as free-form objects, and no output schema. The description supplies only a link, leaving the agent without the field-level context the schema cannot provide.

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 body, confirm and dry_run parameters are already documented in the schema. The description contributes no extra semantics, which meets the baseline of 3 when the schema does the work.

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

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

"Create Wifi Broadcast" restates the tool name (unifi_gen_createwifibroadcast) almost verbatim, so it is close to tautological. It does not differentiate from the near-identical sibling unifi_net_create_wifi or from unifi_gen_updatewifibroadcast, and the only added content is a provenance URL.

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. With both unifi_net_create_wifi and unifi_gen_createwifibroadcast in the sibling list, an agent has no stated rule for choosing one, and no prerequisites or constraints 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?

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered, but the description adds nothing on top: it does not say that deletion is permanent, that the confirm/dry_run preview gate exists, or what a preview returns. The only added text is a provenance URL, which carries no behavioral information.

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

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

It is short and front-loads the operation, but the trailing 'generated from developer.ui.com/.../deleteaclrule' is implementation provenance that consumes 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, irreversible delete with no output schema, the description should warn about permanence and explain the safety gate (a preview unless confirm="YES"). None of that is present, leaving the agent to infer the mutation risk purely from annotations and schema.

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

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

Schema coverage is 67%, and the two documented parameters (confirm, dry_run) are described only in the schema, not the description. The required aclRuleId has no description anywhere, and the description does nothing to explain the preview-vs-apply workflow the parameters encode.

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?

It names a verb (Delete) and a resource (ACL Rule), so the basic operation is identifiable. But it is essentially the tool name expanded, and it gives no way to distinguish it from the near-identical sibling unifi_net_delete_acl_rule that appears in the same sibling list.

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

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

There is no statement of when to use this tool, when not to, or which sibling to prefer for the same operation. The coexistence of unifi_net_delete_acl_rule (and unifi_gen_deletefirewallzone-style equivalents) makes this ambiguity costly.

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 already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so safety is partially covered structurally. The description adds nothing beyond a provenance URL: it never says the deletion is irreversible, what happens to references to the policy, or that omitting confirm yields a preview rather than an execution.

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

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

One short, front-loaded sentence naming the action, plus a provenance tag. Nothing is padded or buried, though the developer.ui.com URL is agent-irrelevant noise rather than useful context.

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

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

For a destructive, open-world mutation with no output schema, the definition should explain irreversibility, the confirm/dry_run gate, and error behavior. None of that appears, and the ambiguity with the sibling delete tool is unresolved.

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?

At 67% schema coverage, two of three parameters (confirm, dry_run) are self-documented, but dnsPolicyId has no description in the schema and none here either. The description contributes zero parameter meaning, so it fails to compensate for the modest coverage gap on the required identifier.

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 DNS Policy'), which is unambiguous on its own. However, it does nothing to distinguish itself from the near-identical sibling unifi_net_delete_dns_policy, leaving the agent to guess which delete-DNS-policy variant to pick.

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 unifi_net_delete_dns_policy, no mention of preconditions, and no warning about when not to delete. The only usage-adjacent information (preview via confirm/dry_run) lives in the schema, not 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?

Annotations already declare destructiveHint=true, idempotentHint=true, readOnlyHint=false, and openWorldHint=true. The description adds nothing beyond a generated-from URL: it does not mention the preview/confirm behavior, irreversibility, or any cascade effects of deletion.

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

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

The single sentence is brief and front-loaded with the action. However, the 'generated from developer.ui.com/...' boilerplate adds no decision value and consumes part of an already sparse 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 deletion operation with no output schema, the description should disclose the preview requirement, irreversibility, and the confirm gate. The schema mentions confirm and dry_run, but the description itself provides no operational context.

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

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

Schema coverage is 67%: confirm and dry_run are documented in the schema, but firewallPolicyId has no description. The tool description adds no semantic meaning to any parameter, so it fails to compensate for the partially undocumented required 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 Firewall Policy. This is clear enough to distinguish it from list/get/create/update siblings, but it does not differentiate itself from the near-duplicate unifi_net_delete_firewall_policy or explain the uuid requirement.

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 unifi_net_delete_firewall_policy or the broader unifi_net_* family. It also omits prerequisites such as requiring the firewallPolicyId or the confirm='YES' gate, leaving usage entirely to inference from the schema.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds nothing beyond a source URL — it doesn't mention the confirm/dry_run preview flow, irreversibility, or what happens to referencing policies.

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-loads the action, but the trailing "generated from developer.ui.com/..." provenance clause consumes roughly half the text 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, open-world mutation with no output schema and an ambiguous duplicate sibling, the description should cover the preview/confirm workflow and ambiguity with unifi_net_delete_firewall_zone. It covers neither.

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 a middling 67%, and the description explains none of the three parameters. The confirm="YES" preview gate and dry_run semantics are documented only in the schema, and firewallZoneId has no description at all in either place.

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 Custom Firewall Zone"), which is clearly a destructive counterpart to get/create/update firewall zone siblings. It does not differentiate from the near-duplicate sibling unifi_net_delete_firewall_zone or explain what a "Custom" zone is.

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 unifi_net_delete_firewall_zone, no prerequisites, and no warning about dependencies such as attached firewall policies. The only usage-relevant text is a provenance URL.

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 already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the description adds little behavioral context beyond restating deletion. It does not explain force semantics, confirmation behavior, or what dry_run previews beyond what is already present in the schema.

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

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

The description is very short and front-loads the operation, but the source URL provenance does not help an agent invoke the tool correctly. Its brevity reflects under-specification more 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 destructive deletion tool with four parameters and no output schema, the description is insufficient. It does not distinguish this generated variant from the sibling delete tool or explain the force/confirmation/preview interactions that matter for safe invocation.

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

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

The description does not mention any parameters, so it cannot compensate for the 50% schema description coverage. The schema covers confirm and dry_run, and networkId has format validation, but force remains undocumented and the description adds no semantic value.

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

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

The description states a specific verb and resource: deleting a network. It is clear but does not differentiate this generated tool from the closely named sibling unifi_net_delete_network.

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

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

The description provides no guidance on when to use this tool versus alternatives such as unifi_net_delete_network. It also does not mention prerequisites, when deletion is appropriate, or how force/preview behavior should affect usage.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — it does not mention that deletion is permanent, what happens to objects referencing the list, or that the schema's confirm/dry_run gates produce a preview unless confirm=YES.

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, but the trailing "generated from developer.ui.com/..." provenance string is metadata that does not help an agent decide or invoke, so the text is not entirely earning its place.

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

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

For a destructive, open-world mutation with no output schema and an undocumented required identifier, the description should at least say where the ID comes from and confirm the preview/confirm flow. None of that context is present, leaving the schema and annotations to carry most of the burden.

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 67%, and the one undescribed parameter is the required trafficMatchingListId, which carries only a UUID pattern with no explanation of what a traffic matching list is or where to obtain its ID. The description adds zero parameter meaning to compensate for that 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 names a specific verb and resource ("Delete Traffic Matching List"), so the basic action is inferable. However, it is effectively a restatement of the tool name plus a documentation URL, and it gives no hint of how this differs from the very similarly named sibling unifi_net_delete_traffic_list or unifi_gen_get/update/create_trafficmatchinglist.

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 warning about irreversibility. An agent must infer everything from the name and 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and openWorldHint=true, so the risk profile is known from structured data. The description adds nothing beyond that: it does not mention irreversibility, the confirm/dry_run safety gate, or the effect on active vouchers. No contradiction with annotations, but no value added either.

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 that is under-specification rather than conciseness. The only substantive content is a generated-from URL, which is metadata noise for an agent deciding how to call 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 destructive, open-world mutation with no output schema and only partial schema coverage, the description should carry real weight but carries none. An agent gets no information about what exactly is removed, whether the operation can be undone, or how the preview/confirm flow behaves beyond what the schema hints at.

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 67%, but the description itself explains none of the three parameters. Notably it does not mention that voucherId is a UUID, that confirm must be literally "YES" for the delete to be applied, or that omitting it returns only a preview – the most consequential semantics of the call.

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?

"Delete Voucher" merely restates the tool name; the only other content is a source-document URL. It never distinguishes this tool from the many nearby siblings such as unifi_net_delete_voucher, unifi_net_delete_vouchers, and unifi_gen_deletevouchers, so an agent cannot tell which delete to pick from the description.

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

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

There is no guidance on when to use this tool, when to prefer the singular/plural or net/gen variants, or what prerequisites apply. The URL pointer to developer.ui.com is documentation provenance, 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?

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so safety framing is covered structurally. The description adds nothing beyond that, and the genuinely consequential behavior - that an unfiltered/broad call could remove many vouchers, and that a preview path exists - is left entirely to the schema's confirm/dry_run fields rather than stated in prose.

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, but a single fragment plus a generated-from URL is under-specified rather than concise. The URL segment earns no place for an agent choosing a 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?

A destructive bulk-delete tool with a required, undocumented filter parameter and no output schema needs the description to explain filtering scope and result behavior. Neither is present, so an agent cannot confidently construct a safe call from this definition 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 coverage is 67%, and the one required parameter, "filter", has no description anywhere - neither in the schema nor in the description. The description would need to compensate by explaining the filter syntax or scope (what identifiers are accepted, whether multiple vouchers can be matched), and it does not.

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?

"Delete Vouchers" names a specific verb and resource, so the basic operation is clear. However, it does not distinguish this bulk delete from the closely named siblings unifi_gen_deletevoucher (singular) and unifi_net_delete_vouchers, and the trailing "generated from developer.ui.com/..." string adds no 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 when-to-use or when-not-to-use guidance and no mention of the singular sibling or the alternative list tools. The only implicit cue is destructive intent from the name and annotations.

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 already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is known. The description however omits the most consequential behavioral detail — that without confirm="YES" the call only previews — leaving a writer that might think a delete happened when it didn't.

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 half the content is a documentation URL rather than an actionable statement. It is front-loaded on the action, though there is nothing of substance behind 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 destructive mutation with no output schema, an undocumented half of the parameters, and a two-step preview/apply flow, the description should explain the confirmation gate and irreversibility. It explains neither.

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 description compensates for none of it: the required wifiBroadcastId is undocumented here and 'force' has no type-independent meaning anywhere. The confirm/dry_run duplication is left to the schema as well.

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 Wifi Broadcast"), so the core action is detectable, but the remainder is a provenance URL that adds no meaning and nothing distinguishes it from siblings like unifi_gen_deletenetwork or unifi_gen_deletevouchers.

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 use this over alternatives, no prerequisites (e.g. that the ID must come from a get/list call), and no exclusions. The agent must infer everything from the name.

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

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

Annotations already flag destructiveHint=true, idempotentHint=false, and openWorldHint=true; the description adds nothing about what gets disrupted, that a device will be restarted, or what the confirm/dry_run safety flow means in practice. The only content beyond the name is a documentation URL, so no behavioral context is contributed.

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 comes from under-specification rather than efficiency: one name-restating line plus a provenance URL, with no front-loaded explanation of the operation.

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

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

For a destructive, non-idempotent, open-world mutation tool with four parameters and no output schema, the description provides nothing an agent needs in order to call it safely or 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 75% and the schema itself explains 'confirm' and 'dry_run'; the description only points to a vendor docs page for the body schema. It adds no meaning about the body's RESTART-only constraint or expected deviceId semantics.

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

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

The description restates the title ('Execute Adopted Device Action') and adds only a generator URL. It never says what the action is (the schema reveals it is a RESTART) nor how it differs from near-duplicate siblings such as unifi_net_device_action, unifi_net_reboot_device, unifi_gen_executeportaction, or unifi_gen_executeconnectedclientaction.

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, when-not-to-use, or alternative routing is given. An agent has to infer from the name alone whether this or the many other device-action siblings should be called.

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 already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered elsewhere. The description itself adds nothing about what gets destroyed, whether authorization is reversible, or that a confirm/dry-run preview flow exists (that only appears in the schema). The docs link is the sole added value.

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

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

It is a single short line with no padding, and the verb+resource is front-loaded. However, the brevity comes from under-specification rather than economy, and the only substantive content is the appended URL.

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-idempotent mutation on a client with a 4-parameter body and no output schema, an agent needs to know what the action does and what the response/preview looks like. The description supplies neither, leaving annotations and schema to carry nearly everything.

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% — body, confirm and dry_run all carry inline descriptions explaining preview-vs-apply behavior, so the schema does the heavy lifting. The description contributes no parameter meaning beyond that, and clientId is undocumented, keeping this at the baseline for a mostly-covered 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 restates the tool name ("Execute Client Action") and appends a vendor docs URL, adding essentially no explanatory content. It does not say what the action does, what action types exist (only the schema enum reveals AUTHORIZE_GUEST_ACCESS / UNAUTHORIZE_GUEST_ACCESS), or how it differs from close siblings like unifi_net_client_action or unifi_net_block_client.

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, despite the sibling list containing several overlapping client-manipulation tools (unifi_net_client_action, unifi_net_block_client, unifi_net_unblock_client). The only implied usage cue is the linked vendor documentation page, which the agent would have to fetch separately.

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 already declare destructiveHint=true, readOnlyHint=false, and non-idempotent behavior, so the safety profile is known. The description adds nothing beyond that: it never says that POWER_CYCLE disrupts a live port, never mentions the confirm/dry_run safety pattern, and never explains what happens on execution. It is a name plus a URL, contributing no 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 action name, so it is not bloated. However, half of its content is a provenance URL ('generated from developer.ui.com/...') rather than information that helps an agent decide or invoke, so its brevity reflects missing content rather than efficiency.

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-idempotent mutation with five parameters, two undocumented required fields, and no output schema, the description should carry substantial weight. Instead it offers only a vendor doc link, leaving the agent unable to determine effect scope, prerequisites, or return behavior from the definition itself.

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 60%: body, confirm, and dry_run are documented in the schema, but the two required parameters portIdx and deviceId have no descriptions beyond min/max and a UUID pattern. The description does not compensate at all — it says nothing about port index numbering or how to obtain a deviceId.

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 restates the tool name ('Execute Port Action') and appends a documentation URL, which is effectively tautological. It never explains what a 'port action' does in this API (the schema hints at POWER_CYCLE only inside the body const), and it does not distinguish itself from the sibling unifi_net_port_action, which appears to offer overlapping capability.

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

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

There is no guidance at all about when to use this tool, when not to, or how it relates to alternatives such as unifi_net_port_action, unifi_net_device_action, or unifi_gen_executeadopteddeviceaction. The presence of a near-identical sibling makes this absence costly, though the text is not actively misleading.

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 already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds no behavioral context of its own (no auth requirements, no scope, no return shape) beyond a source URL, so it contributes almost nothing beyond the annotations.

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. The appended 'generated from...' URL is filler that does not help an agent invoke the tool, but overall the definition wastes little 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 read tool with no output schema, the description should indicate what the returned ACL rule contains and how the ID is sourced. It offers neither, and there is no differentiation from the duplicate sibling, so an agent lacks enough 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 0% and the single aclRuleId parameter is documented only by its uuid format and regex pattern, with no prose. The description does not explain what an ACL rule ID refers to or how to obtain one, 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 and resource (get a single ACL Rule), which distinguishes it from list/create/update/delete variants. However, it does not differentiate from the near-duplicate sibling unifi_net_get_acl_rule, leaving the agent unable to choose between them from the description alone.

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

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

There is no guidance on when to use this versus unifi_net_get_acl_rule or the list/page variants, and no prerequisites are mentioned. The trailing URL is provenance metadata, not usage context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no note on what the ordering payload looks like, whether it is site-scoped, or permission requirements — so it earns little credit over the annotations.

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

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

A single short sentence with the operation front-loaded. The trailing 'generated from developer.ui.com/...' provenance adds little for an agent but is not 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 output schema, the description is the only place an agent could learn what 'ordering' returns (e.g., a list of rule IDs in priority sequence), and it says nothing about that. For a read tool whose entire value is its return shape, this is a meaningful 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 there is no parameter semantics to explain; the baseline for a 0-param tool applies. Nothing in the description misleads about 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 names a specific verb and resource ('Get User-Defined ACL Rule Ordering'), so an agent knows it retrieves the ordering of user-defined ACL rules rather than the rules themselves. However, it does not distinguish itself from the near-identical sibling unifi_net_get_acl_rule_ordering, which appears to do the same thing.

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 sibling unifi_net_get_acl_rule_ordering or the reorder tool unifi_gen_updateaclruleordering. The only context is the 'generated from' provenance string, which does not help an agent choose.

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

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

The annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds only provenance ('generated from developer.ui.com/network/v11.0.97/getaclrulepage'), which adds nothing about behavior related to pagination, default return size, or filter semantics.

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

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

One short, front-loaded sentence with the action stated first. The trailing provenance URL is of marginal value to an agent but adds little bloat.

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

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

There is no output schema, and three parameters are undocumented everywhere. For a paginated list endpoint, an agent needs the filter format and paging defaults, and neither the description nor the schema supplies them.

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 0%: limit, filter, and offset are all undocumented, and the description does not explain the filter string syntax, that limit caps at 200, or the default page size. The single word 'List' implies pagination at most.

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: 'List ACL Rules'. It is clear what the tool returns, but it does not distinguish itself from the sibling unifi_net_list_acl_rules, which appears to serve the same 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 is given about when to use this tool or when to use another tool instead. Given that the sibling list unifi_net_list_acl_rules overlaps, the absence of any routing hint leaves the agent to guess.

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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered upstream. The description adds nothing on top of that — no note about what the returned detail set contains, whether it reflects live or cached state, or what happens for non-adopted/nonexistent device IDs.

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, which is good, but roughly half the text is an auto-generated provenance URL that carries no actionable meaning for an agent choosing or calling the tool.

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

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

With no output schema and a 0%-described parameter, the description is the only place an agent could learn what 'details' covers and how deviceId is sourced — and it supplies none of that. For a lookup tool whose whole value is the returned payload, this is under-specified.

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

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

Schema description coverage is 0% for the single required parameter deviceId, so the description must compensate and fails to: it never says the UUID identifies an adopted device, nor distinguishes it from a client ID or site ID. The schema's format/pattern gives shape but not semantics.

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

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

The name is restated as 'Get Adopted Device Details', which gives a verb and a resource, so the basic purpose is legible. But it offers no differentiation from close siblings like unifi_gen_getadopteddeviceoverviewpage or unifi_gen_getadopteddevicelateststatistics, and the trailing 'generated from developer.ui.com/...' provenance line is metadata rather than 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 statement of when this tool should be used instead of the overview page, latest-statistics, or unifi_net_get_device alternatives that appear in the sibling list. The agent is left to infer the selection rule entirely from tool names.

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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered by structured data. The description adds nothing beyond that — no indication of what statistics are returned, over what time window, whether the device must be currently adopted/online, or how fresh the data is.

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

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

A single short sentence with the purpose front-loaded, which is good. However, roughly half the text is a generator/provenance URL that adds little decision value for an invoking 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?

No output schema exists, so the description would need to convey what "latest statistics" returns, and it does not. Combined with an unexplained required UUID parameter and several competing sibling tools, an agent cannot confidently call this correctly from the definition 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 single parameter (deviceId) has 0% schema description coverage; the schema supplies only type, uuid format, and a regex pattern. The description does not mention deviceId at all, nor clarify whether it must be an adopted device ID versus a generic device identifier — a gap the schema cannot fill.

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 Latest Adopted Device Statistics"), so the agent knows the general domain, but it does not distinguish itself from near-identical siblings such as unifi_net_get_device_stats, unifi_gen_getadopteddevicedetails, or unifi_gen_getadopteddeviceoverviewpage. "Latest" and "statistics" are left undefined, so the exact scope is unclear.

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 sibling device-statistics/detail tools, and no prerequisites or exclusions are stated. The only extra information is a provenance URL, which does not help tool selection.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds nothing beyond that — no mention of pagination behavior, whether 'adopted' excludes pending devices, or what the overview response 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?

It is short and front-loads the action, but roughly half the text is a provenance URL ('generated from developer.ui.com/...') that gives the calling agent no operational 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 paginated list endpoint with no output schema and undocumented parameters, the description should at minimum describe return shape and paging semantics. Neither is present, so an agent cannot confidently 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 0% across three parameters; 'filter' in particular is an opaque string whose syntax is documented nowhere. The description provides no compensating explanation of limit/offset paging or filter grammar, so the agent is left guessing at the most consequential 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 verb and resource ('List Adopted Devices'), so the basic action is identifiable. But it does not differentiate from closely-named siblings such as unifi_gen_getadopteddevicedetails, unifi_gen_listdevices, or unifi_net_list_devices, leaving ambiguity about what makes this 'overview page' distinct.

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 unifi_gen_getadopteddevicedetails or the other device-listing tools. The agent must infer that this is the paginated overview endpoint 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds nothing beyond a documentation URL — no note on what the detail payload contains, whether it requires the client to be actively connected, or any failure mode (e.g., unknown clientId).

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 operation name, which is good, but the remainder is a generated provenance URL that adds little actionable value for an agent and consumes half 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?

With no output schema and zero parameter documentation, the description should explain what 'details' are returned and how to supply the client identifier. Instead it gives only a source URL, leaving an agent unable to predict the response shape or the precondition that the client be currently connected.

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

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

Schema description coverage is 0%, so the description must compensate for the single required parameter. It never mentions clientId, where to obtain it (e.g., from a list-clients call), or how it relates to the connected client entity — only the schema's UUID pattern hints at the format.

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 ('Get Connected Client Details'), so the agent knows this retrieves the detail record for a single connected client. However, it does not distinguish this from close siblings such as unifi_net_get_client or unifi_gen_getconnectedclientoverviewpage, leaving ambiguity about which client-retrieval tool to pick.

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 unifi_net_get_client, the connected-client overview page tool, or the client action tool. The agent must infer that this requires a known clientId and returns full details rather than a 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds nothing about pagination behavior, total-count fields, default page size, or result ordering — all relevant for a paged listing endpoint. The provenance URL is metadata, not 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?

One line, front-loaded with the action. The trailing "generated from developer.ui.com/..." is provenance noise that doesn't help invocation, but it costs little.

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

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

No output schema, no parameter documentation, and a terse label — for a paginated list endpoint with a free-form filter string, this leaves large gaps. The description should say what the page returns and how filter/limit/offset work together.

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?

Three parameters (limit, filter, offset) have 0% schema description coverage, so the description carries the full burden — yet it mentions none of them. The agent gets no idea of filter syntax, whether filter is a query string or JSON, or that limit is capped at 200.

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?

"List Connected Clients" gives a verb and resource, so the basic intent is clear. But it never distinguishes itself from the very similar siblings unifi_net_list_clients and unifi_gen_getconnectedclientdetails, and the description doesn't explain what an "overview page" contains versus 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?

There is no indication of when to use this tool rather than unifi_net_list_clients or unifi_gen_getconnectedclientdetails, despite both being present in the sibling list. The only additional text is a source-URL provenance note, which gives the agent no routing 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is fully covered. The description adds only a provenance URL with an API version, which is not behavioral context; it says nothing about pagination defaults, filter behavior, or result shape.

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

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

A single short sentence with the purpose front-loaded; nothing is padded. The trailing 'generated from developer.ui.com/...' clause is the only arguably non-essential text, though it hints at the upstream spec.

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

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

For a simple read-only list endpoint with annotations covering safety and no output schema, the description is minimally sufficient to call the tool. It is still incomplete regarding the filtering/pagination semantics and the overlap with the duplicate 'unifi_net_list_countries' tool, which an agent would need to choose 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% and three parameters (limit, filter, offset) are documented nowhere. The description does not compensate at all — no mention of the 200-item limit cap, what 'filter' accepts, or default page size — though the conventional pagination names make the gap somewhat less severe than fully opaque 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 specific verb and resource ('List Countries'), so the agent knows exactly what the tool returns. However, it does nothing to distinguish itself from the sibling 'unifi_net_list_countries', which appears to do the same thing, leaving ambiguity unresolved.

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 near-identical 'unifi_net_list_countries' sibling, nor any stated preconditions or exclusions. The only signal is the name itself, which implies a read-only enumeration.

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 already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds nothing beyond that — no mention of how limit/offset pagination behaves, no default page size, and no indication that this is the raw/generated variant of the 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?

Very short, so nothing is bloated, but the second half is a provenance pointer ('generated from developer.ui.com/...') that occupies space without helping the agent invoke the tool. The useful content is a single noun phrase with no front-loaded operational 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?

Three undocumented parameters including an opaque 'filter' object, no output schema, and a confusing overlap with a sibling tool — this definition should do considerably more. It gives the agent no basis for constructing a paginated or filtered request.

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 all three parameters, and the 'filter' parameter has an entirely empty schema ({}), so neither the schema nor the description explains what it accepts. The description does not compensate at all; it names no parameters, no formats, and no defaults.

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 ('List Device Tags'), which is clear enough to know what the tool returns. However it makes no attempt to distinguish itself from the sibling unifi_net_list_device_tags, which appears to do the same thing.

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 unifi_net_list_device_tags, which is a near-identical sibling. The agent is left to guess which of the two tag-listing endpoints to call, and nothing is said about prerequisites or scope.

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 already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds nothing beyond a documentation URL — no note on error behavior for an unknown ID, response shape, or any context beyond what annotations supply.

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

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

It is a single short line with no padding, but it is also almost entirely content-free apart from the source-URL provenance. Brevity here comes from under-specification rather than disciplined writing.

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

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

For a lookup tool with an undocumented parameter and a duplicate-named sibling, the description does not equip the agent to choose or invoke it correctly. The 'generated from' URL is provenance, not usable operational context.

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

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

Schema description coverage is 0%, and the description does not mention dnsPolicyId at all. The agent must infer from the name and UUID format that it is the policy identifier; nothing is said about where to obtain it (e.g., from unifi_net_list_dns_policies).

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 DNS Policy'), so the basic action is identifiable. But it offers no scope detail and does not distinguish this tool from the near-identical sibling unifi_net_get_dns_policy, leaving the agent to guess which to call.

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 unifi_net_get_dns_policy or unifi_net_list_dns_policies. Usage is only inferable from the tool name and the single required ID parameter.

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 already declare readOnlyHint, idempotentHint, and non-destructive, so the safety profile is covered. Beyond that the description adds only the upstream API path (v11.0.97/getdnspolicypage); it says nothing about pagination behavior for limit/offset, result ordering, or what a call returns.

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

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

One line, front-loaded with the action and resource. The provenance clause is marginal filler but harmless; nothing bloats 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 paginated list tool with three undocumented parameters and no output schema, the description should explain pagination semantics and the filter parameter's format. It also omits how to distinguish this generated mirror from the native unifi_net_list_dns_policies.

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?

All three parameters (limit, offset, filter) have 0% schema description coverage, and the description provides no compensating detail. limit/offset are conventional enough to guess, but the filter syntax and accepted fields are completely opaque.

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?

"List DNS Policies" names a specific verb and resource, so an agent can tell it enumerates DNS policies. However, it gives no hint on how this differs from the sibling unifi_net_list_dns_policies, and the "generated from..." suffix adds provenance rather than 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 when-to-use guidance, no prerequisites, and no mention of the nearly identical sibling unifi_net_list_dns_policies or unifi_gen_getdnspolicy for single-item retrieval. 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds nothing behavioral beyond a provenance URL: no pagination behavior, no filter semantics, no indication of what the response contains or how large the category set typically is.

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

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

It is a single short, front-loaded line with no padding, which is good. But roughly half of it is a generator URL that conveys no actionable information to the calling 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?

It is a read-only list endpoint with rich annotations and no required parameters, so the bar is genuinely low. Still, for a paginated, filterable list the description should say something about return size or filter matching, and it does not.

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

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

Schema description coverage is 0%, so the description carries the full burden for limit, filter and offset, yet it mentions none of them. The agent is left to infer the filter syntax (matching on name? id?) and pagination defaults entirely on its own.

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

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

States a specific verb (List) and resource (DPI Application Categories), which is enough to distinguish it from most siblings. However, it gives no differentiation from the near-identical sibling unifi_net_list_dpi_application_categories nor from unifi_gen_getdpiapplications, leaving the agent to guess which variant to call.

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, when not to, or which alternative to prefer. Given that two near-duplicate siblings exist (unifi_net_list_dpi_application_categories and unifi_gen_getdpiapplications), this omission is significant.

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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing behavioral beyond a docs URL — no pagination behavior, no result size expectations despite a 200-item limit cap, and no note on what 'filter' matches.

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

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

The single sentence is front-loaded and wastes no words on repetition of the input schema. However, it is under-specified rather than concise, and the appended developer.ui.com versioned URL is noise that consumes 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?

With no output schema, three undocumented query parameters, and two near-duplicate sibling list tools, the description should explain the filter/pagination contract and the difference from unifi_net_list_dpi_applications. None of that is present, leaving real ambiguity for an agent with no required parameters to anchor on.

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

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

Schema description coverage is 0%, so the description carries the full burden for limit, offset and filter — yet it mentions none of them. The parameter names are largely self-explanatory and bounds are in the schema, but the critical question of filter syntax (name match? prefix? case sensitivity?) is left entirely unresolved.

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 ("List DPI Applications"), which is enough to know the operation is a read-only enumeration of DPI application entries. It does not, however, distinguish this from close siblings such as unifi_net_list_dpi_applications or unifi_gen_getdpiapplicationcategories, forcing the agent to guess which of the three to call.

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 exclusion of alternatives, and no mention of prerequisites such as site or network scoping. The only additional text is a source URL, which tells the agent nothing about when this tool is the right choice over its nearly identical siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing behavioral beyond a source-doc citation — no mention of pagination behavior, default page size, result ordering, or how the open-world 'filter' query is applied.

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, which is good, but half the content is a 'generated from developer.ui.com/...' provenance note that provides no value to an invoking agent. The brevity here reflects under-specification rather than disciplined concision.

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

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

Placeholder check: this dimension is scored on the definition as a whole. With a read-only list tool, annotations covering safety, no output schema required, and no required parameters, an agent can invoke it correctly with a bare call; the missing filter grammar is the main residual gap and is penalized under parameter_semantics.

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 all three parameters (limit, offset, filter) are undocumented anywhere. The description makes no attempt to explain them, and 'filter' in particular has an unknown syntax/grammar that an agent cannot infer from 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 gives a clear verb+resource ('List Firewall Policies'), which is enough for an agent to know it enumerates the collection rather than fetching one policy like unifi_gen_getfirewallpolicy. It does not, however, distinguish itself from the near-identical sibling unifi_net_list_firewall_policies, nor does it state scope (site-level? all sites?).

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 when to prefer this over unifi_net_list_firewall_policies, and no note about pagination or prerequisites. The only usage-adjacent text is a documentation URL, which is not actionable guidance for tool selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered structurally. The description adds nothing behavioral beyond a documentation-source URL — no error behavior for an unknown ID, no return shape, no auth notes.

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 with the action. The trailing "generated from developer.ui.com/..." provenance string is metadata noise rather than useful guidance, keeping it out of the top score.

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 lookup with no output schema, the description should at least say what is returned or how to source the ID. With annotations carrying the safety profile, the remaining burden on the description is modest but still unmet.

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 firewallPolicyId has 0% schema description coverage; the schema supplies only type/format/pattern. The description never explains that the value is a policy UUID or where to obtain one, 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 names a specific verb and resource ("Get Firewall Policy"), so the basic action is clear, and the singular form hints at a single-record fetch versus the sibling list tool. However, it offers no differentiation from the near-duplicate sibling unifi_net_get_firewall_policy, and the only other content is a provenance URL.

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 unifi_gen_getfirewallpolicies or unifi_net_get_firewall_policy, and no stated prerequisite such as needing an ID obtained from a list call. 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered structurally. The description adds only the 'User-Defined' scope qualifier and says nothing about what ordering data is returned, whether zones must be a valid pair, or what happens when no policies exist between the zones.

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, so it is not padded in length. However, the second half ('generated from developer.ui.com/...') is machine provenance that consumes space without informing the agent's decision, so not every element earns its place.

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

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

With no output schema, the description is the only place that could explain the return shape — presumably an ordered list of policy IDs for the zone pair — and it says nothing about it. For a tool whose entire purpose is order, omitting how order is represented is a material gap.

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

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

Schema description coverage is 0% and neither parameter has a description, so the description carries the burden of explaining sourceFirewallZoneId and destinationFirewallZoneId — including that both must be valid existing zone UUIDs and that the pair defines the ordering direction. It supplies none of that; only the self-evident property names carry 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 phrase 'Get User-Defined Firewall Policy Ordering' names a verb and a resource, so the basic operation is inferable. But it does not differentiate from the near-identical siblings unifi_net_get_firewall_policy_ordering and unifi_gen_updatefirewallpolicyordering, so an agent cannot tell which of the three to pick from the description alone.

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

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

There is no statement of when to use this tool, no exclusions, and no pointer to the sibling that returns or mutates ordering. The only remaining sentence is a provenance note ('generated from developer.ui.com/...'), which is 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds nothing beyond a source documentation link — no information on behavior when the ID is unknown, whether it returns 404/empty, or required permissions.

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 this is under-specification rather than conciseness. The one non-redundant element is the developer.ui.com link, which is provenance metadata rather than actionable information for the calling 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?

Annotations cover safety and there is no output schema, but the description still leaves the entire parameter undocumented and gives no hint about the returned zone object shape. For a lookup tool with a required UUID argument, this is a bare-minimum definition.

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

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

There is one required parameter (firewallZoneId) with 0% schema description coverage; the schema supplies only a UUID format/pattern with no prose meaning. The description does not mention the parameter at all, so it fails to compensate for the coverage gap — the agent cannot tell whether this is a zone UUID, name, or something else.

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 restates the tool name/title ('Get Firewall Zone') and adds only a provenance URL. It does not distinguish this tool from the near-identical sibling unifi_net_get_firewall_zone or clarify the singular-vs-list relationship with unifi_gen_getfirewallzones.

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 whatsoever on when to use this versus unifi_net_get_firewall_zone, unifi_gen_getfirewallzones, or unifi_net_list_firewall_zones. The agent must infer everything from the tool 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that: no pagination defaults, no maximum result behavior (limit caps at 200), and no note that filter syntax is undocumented. Only the 'generated from developer.ui.com' provenance is added, which is not behaviorally useful.

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

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

It is a single short, front-loaded line, so there is no padding in the sentence itself. However, the appended developer.ui.com URL is dead weight that consumes half the text 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?

There is no output schema, so the description should say what a firewall zone record contains and how pagination results are returned; it says neither. For a parameterized, open-world list tool this leaves the agent with more unknowns than knowns.

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?

All three parameters (limit, filter, offset) have 0% schema description coverage, so the description must carry their meaning and does not mention any of them. The filter string in particular is completely unexplained, leaving an agent with no way to construct a valid query.

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?

"List Firewall Zones" gives a clear verb plus resource, but it stops at restating the tool name. There is a near-identical sibling (unifi_net_list_firewall_zones) and a singular variant (unifi_gen_getfirewallzone), and the description offers no basis for choosing between them. The trailing source URL is provenance metadata, not purpose information.

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 rather than unifi_net_list_firewall_zones, when to page with limit/offset, or what filter accepts. An agent is left entirely to inference 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so safety is covered. The description adds nothing beyond a source URL — no note on what a 'host' is in this API, what the response contains, or whether an unknown ID errors versus returns empty.

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, which is good, but half of the text is auto-generated provenance boilerplate that does not help an agent decide or invoke. Brevity here reflects under-specification rather than disciplined editing.

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

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

No output schema exists, so the description is the only place an agent could learn what a host record contains or how to obtain a valid id — and it says neither. For a generated single-entity lookup tool, that leaves a meaningful gap.

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

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

Schema description coverage is 100% and the single `id` parameter is documented as 'Unique identifier of the host', so the schema carries the load. The description adds no syntax, format, or provenance detail about where an id comes from (e.g., a listhosts call), so baseline 3 applies.

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

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

The description restates the tool name almost verbatim ("Get Host by ID") plus a provenance URL, which is essentially tautological against the title. It does convey the verb (retrieve) and the resource (host, keyed by id), but gives no differentiation from siblings such as unifi_sm_get_host or unifi_gen_listhosts.

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, and the sibling set contains a near-duplicate (unifi_sm_get_host) that an agent would need help disambiguating. No prerequisites, no scope notes, no exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the annotations, such as what data is returned, whether authentication is needed, or any rate-limit characteristics.

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 with the action, which is good. However, the trailing 'generated from developer.ui.com/...' clause is provenance metadata that does not help an agent select or invoke the tool, so not every sentence earns its place.

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

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

With no output schema and no parameter schema of substance, the description carries the burden of explaining what 'Application Info' actually returns. It does not do so, and it also fails to distinguish this tool from closely named siblings, leaving the agent under-informed despite the tool's simplicity.

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

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

The tool has zero parameters, so parameter semantics are not a concern. The baseline of 4 applies because there is nothing for the description to compensate for.

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 and resource ('Get Application Info'), so the basic action is clear. However, 'Application Info' is vague about what application or data is meant, and there is no differentiation from sibling tools such as unifi_net_get_info or unifi_sm_identity.

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

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

There is no guidance on when to use this tool versus alternatives, nor any stated context or prerequisites. The description merely names the operation and cites a source URL, leaving routing decisions 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds nothing beyond that – no note on granularity tradeoffs, data freshness, retention windows, or why 5m only pairs with 24h and 1h only with 7d/30d.

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 the purpose is front-loaded, but roughly half the text is a generator provenance URL rather than information useful for tool selection. Brevity here reflects under-specification rather than disciplined editing.

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

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

For a four-parameter metrics-retrieval tool with no output schema, the description says nothing about what is returned (latency, jitter, packet loss, availability?), units, or per-site vs. aggregate scope. The schema compensates for parameters, but the return-value burden falls entirely on an undocumented description.

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 mutual exclusivity of duration vs. beginTimestamp/endTimestamp and the 5m/1h interval semantics are already documented in the schema. The description adds no additional parameter meaning, which is the baseline-3 case.

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 is essentially the tool name humanized ("Get ISP Metrics") plus a provenance URL. It restates the title rather than explaining what ISP metrics are or what scope is retrieved, and it makes no attempt to separate this from close siblings such as unifi_sm_get_isp_metrics, unifi_sm_query_isp_metrics, or unifi_gen_queryispmetrics.

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 exclusions, and no pointer to the several near-duplicate ISP metrics siblings. An agent must infer from the name alone that this is a read of ISP health/performance data.

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 already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds nothing beyond that, such as return shape, permission requirements, or rate-limit behavior; the only extra clause is a source-code provenance note.

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 useful phrase 'Get LAG Details'. However, roughly half of it is a 'generated from developer.ui.com...' provenance note that does not help an agent select or invoke 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 read tool this is thin: it does not explain what LAG details include, how lagId is obtained, or how it differs from sibling LAG tools. Annotations cover the safety profile, but the description leaves practical invocation context missing.

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

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

Schema description coverage is 0%, so the description must carry the burden of explaining lagId. It does not: lagId is self-identifying as an identifier and the schema constrains it to a UUID, but the description never says where to get it or what a LAG refers to in this context.

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 LAG Details'. It does not, however, distinguish this from sibling tools such as unifi_net_get_lag, unifi_gen_getlagpage, or unifi_net_list_lags, so an agent cannot tell which LAG-fetching tool to choose without inspecting schemas.

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. The description does not explain when a single LAG lookup is appropriate compared with listing LAGs or using the page-level sibling, nor does it mention prerequisites for obtaining a lagId.

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 already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds nothing about pagination behavior, result limits, or what the generated `filter` string accepts — context that matters for a paginated 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?

Two short clauses, front-loaded with the verb and resource, no filler. The generated-from URL adds little for an agent but does not bloat the text.

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 generated endpoint with zero schema coverage, no output schema, and near-duplicate siblings, the description should at minimum explain the filter/pagination contract and how it relates to unifi_net_list_lags. It supplies none of that.

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% across three parameters, so the description carries the full burden and fails to meet it. Nothing explains the `filter` syntax or what `limit`/`offset` page over, beyond what the bare property names imply.

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 ("List LAGs"), so the basic operation is legible. However, it does not distinguish this tool from close siblings such as unifi_net_list_lags, unifi_gen_getlag, or unifi_net_get_lag, leaving the agent unable to tell why there are duplicates or which to prefer.

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, when not to, or which alternative sibling to pick for multi-LAG vs single-LAG retrieval. The only extra text is a provenance URL, which gives no selection 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?

The annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds nothing beyond that — not what happens when the ID is unknown, not the error shape, and not the (likely Unifi-API-backed) authorization context implied by openWorldHint.

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

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

One short sentence with the resource front-loaded, plus a compact provenance reference. There is no filler, though the versioned docs URL adds little for an agent deciding how to call 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 single-parameter read tool whose annotations carry the safety profile, this is minimally sufficient. The remaining gaps — how to obtain the ID and which of several lookalike MC-LAG tools to use — are real but not fatal.

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

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

Schema description coverage is 0%, and the description never mentions mcLagDomainId, so it does nothing to compensate. An agent gets the UUID format from the schema but no hint that the value should be sourced from the MC-LAG domain list endpoint.

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 MC-LAG Domain"), so an agent knows exactly what kind of object is retrieved. It does not, however, distinguish this from the near-identical siblings unifi_net_get_mclag_domain and unifi_gen_getmclagdomainpage, leaving the agent to guess which retrieval variant to call.

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: no prerequisites, no note on where a domain ID comes from, and no exclusion pointing to list_mclag_domains or the net-namespace equivalent. The only extra text is a source URL, which is provenance rather than usage instruction.

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 already declare readOnly, idempotent, non-destructive, open-world, so safety is covered. The description adds nothing beyond a source URL: no pagination behavior, no default ordering, no indication of what a page contains or how limit/offset interact.

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

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

One short, front-loaded sentence with no padding. Slightly under-specified rather than verbose; the trailing 'generated from' URL is low-value but cheap.

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 paginated list tool with no output schema and no parameter documentation; the description doesn't say what fields a domain record has, whether results are paged, or how to page. For a zero-annotation-gap read tool the bar is lower, but this still leaves the agent guessing.

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 0% and the description says nothing about limit, filter, or offset. The names are conventional pagination/filter params, but no filter syntax, max page size behavior (limit caps at 200), or default is disclosed anywhere.

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?

Specific verb and resource ('List MC-LAG Domains'), so an agent knows what it returns. However it does not differentiate from the near-identical sibling unifi_net_list_mclag_domains, and the trailing doc URL adds no disambiguation.

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, when-not-to-use, or alternative named. With siblings like unifi_net_list_mclag_domains and unifi_gen_getmclagdomain covering the same resource, the absence of routing guidance is a real gap.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered without the description. The description adds nothing about what a 'network detail' contains, error behavior for invalid/unknown IDs, or permissions — the 'generated from developer.ui.com/.../v11.0.97/getnetworkdetails' note only signals the upstream API version.

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 shortness here is under-specification rather than concision; the only content beyond the title is a provenance URL. Nothing is front-loaded because there is nothing substantive to front-load.

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 detail-fetch tool with a required identifier and no output schema needs the description to explain what is returned and how it differs from other network getters. Nothing of the sort is present, leaving the agent unable to predict the response shape or pick correctly among 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 description coverage is 0%, so the description carries the full burden of explaining the single parameter, yet it says nothing. An agent must infer that networkId is the UUID of a UniFi network, and specifically which network identifier (site-scoped? overlay? VLAN?) is expected.

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

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

The description restates the name ('Get Network Details') with no elaboration, which is effectively a tautology. It gives no way to distinguish this from close siblings such as unifi_net_get_network, unifi_gen_getnetworkreferences, or unifi_gen_getnetworksoverviewpage, which all sound like they return network details.

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 sibling getters, no preconditions, and no exclusions. The only additional text is a source URL for the upstream API spec, which is not usage instruction.

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 already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — no statement of what is returned, whether references reflect dependent objects (firewall policies, Wi-Fi, etc.), or whether results can be large/truncated.

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, so it is not bloated. But the brevity is under-specification rather than efficiency: the second half of the single sentence is a provenance URL that conveys nothing an agent can act on.

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

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

No output schema exists, so the description should explain what a reference list looks like; it does not. Combined with an undocumented required parameter and a duplicated sibling, an agent cannot confidently decide to call this tool or interpret its 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?

Schema description coverage is 0% for the single required networkId parameter, and the description supplies no compensating meaning — it does not say what a networkId identifies, where to obtain one, or what happens with an invalid/unknown ID. The description carries the full burden here and discharges none of it.

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 restates the tool name ("Get Network References") and appends a documentation URL. It never explains what a "network reference" is or what entity is being retrieved, and it does nothing to distinguish this from the near-identical sibling unifi_net_get_network_references, which appears in the same tool list.

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

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

There is no guidance on when to call this versus unifi_net_get_network, unifi_net_get_network_references, or unifi_gen_getnetworkdetails — all of which plausibly overlap. The only added text is a source URL, which is 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is fully covered. The description adds nothing beyond that: no mention of pagination behavior (despite limit/offset), no note on whether the list is site-scoped, and no hint about response volume. With the lower bar set by annotations, this is still a thin contribution.

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 action, which is good, but the second half is a provenance URL that does not help an agent select or invoke the tool. Brevity here reflects under-specification rather than disciplined editing.

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

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

For a paginated list tool with three undocumented parameters, no output schema, and a same-purpose sibling, the description is materially incomplete. An agent cannot determine the filter syntax, the default page size, or how this differs from unifi_net_list_networks.

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% across three parameters, so the description carries the full burden and delivers nothing. "filter" in particular is an untyped string with no syntax, field names, or format disclosed, and limit/offset bounds and defaults are left entirely implicit.

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?

"List Networks" gives a clear verb and resource, but the definition offers no way to distinguish it from the near-identical sibling unifi_net_list_networks, nor from unifi_gen_getnetworkdetails. The trailing provenance string ("generated from developer.ui.com/network/v11.0.97/getnetworksoverviewpage") identifies the upstream endpoint, not the tool's scope, so an agent still cannot tell which of the two network-listing tools to pick.

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-tool guidance anywhere in the description. Given that the sibling list contains both unifi_net_list_networks and unifi_gen_getnetworkdetails, the absence of routing guidance leaves the choice 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false. The description adds only provenance ('generated from...'), not behavioral context such as pagination, filtering, or return format.

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 tool purpose. The provenance note is somewhat dispensable, but the overall structure is 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 a list tool with three undocumented parameters and no output schema, the description is not complete enough to guide correct invocation. It omits filter syntax, pagination behavior, and response expectations.

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 all three parameters (limit, filter, offset), and the description does not explain any of them. The description does nothing to compensate for the missing schema documentation.

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

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

The description states a specific verb and resource: 'List Devices Pending Adoption.' It is clear what the tool does, but it does not distinguish itself from the sibling tool unifi_net_list_pending_devices.

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

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

The description does not say when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. Usage is only implied by the name and description.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond that — no note on pagination behavior, default page size, result completeness, or what the 'generated from' API endpoint implies for output shape.

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

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

One short, front-loaded sentence with no padding. The trailing 'generated from developer.ui.com/...' provenance is mildly useful for tracing the underlying API but is not behavioral information, keeping this just short of a 5.

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

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

With no output schema, zero-described parameters, and a duplicate sibling, the description is the only place an agent could learn what the tool returns or how to page/filter. It supplies none of that, so an agent cannot call it correctly without guessing.

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 three parameters (limit, offset, filter). While limit/offset are self-explanatory pagination names, the description says nothing about the filter string syntax or what fields it matches on — the parameter that most needs explanation is left entirely undocumented.

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

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

The description gives a specific verb and resource ('List Radius Profiles'), so the basic operation is unambiguous. However, it does nothing to differentiate this tool from the near-identical sibling 'unifi_net_list_radius_profiles' in the same toolset, leaving the agent to guess which of the two to call.

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 the sibling list tool, no mention of pagination expectations, and no prerequisites or context. The only guidance is the implicit 'it lists radius profiles', which the name already conveys.

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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds nothing beyond the name — no note on what is returned, whether a missing ID errors, or permissions required — so the lower bar set by annotations still isn't met with extra value.

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 with the action, but the "generated from developer.ui.com/..." suffix is internal provenance noise that consumes half 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 one-parameter read operation with full schema coverage and complete annotations, the essentials are present. What is missing is any link to the list-sibling for discovery of IDs, which is the practical hurdle for calling this 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% and the single id parameter is documented as the unique identifier of the SD-WAN configuration. The description adds no format or sourcing detail beyond the schema, so the baseline of 3 applies.

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

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

The description names a specific verb and resource ("Get SD-WAN Config by ID"), which is unambiguous on its own. It does not differentiate from its obvious siblings such as unifi_gen_listsdwanconfigs or unifi_sm_get_sdwan_config, so an agent must infer the distinction from the names 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 SD-WAN list tool or the alternative get_sdwan_config variants. The only appended text is a provenance URL, which gives no usage context.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description adds no behavioral context of its own — no indication of what status fields come back, whether the id refers to a config or a site, or whether results are cached/live. The only added text is a provenance URL.

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 purpose, which is good, but the trailing 'generated from developer.ui.com/...' provenance string occupies a meaningful share of an already minimal description without helping the 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?

No output schema exists, yet the description never says what a 'config status' response contains or how it differs from the config itself. For a tool whose whole value is a status payload, that is a substantive gap even though the single parameter is well 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 description coverage is 100% and the single 'id' parameter is documented as the SD-WAN configuration identifier, so the baseline applies. The description adds no extra meaning about where that id comes from (presumably listsdwanconfigs) or how it is formatted.

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 SD-WAN Config Status'), but the resource is ambiguous next to siblings like unifi_gen_getsdwanconfigbyid, unifi_gen_listsdwanconfigs, and unifi_sm_get_sdwan_config_status. Nothing explains what a 'config status' is versus a config, so the agent cannot confidently pick this tool from the family without opening schemas.

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 named alternatives (getsdwanconfigbyid, listsdwanconfigs, unifi_sm_get_sdwan_config_status). The agent must infer selection 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?

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds nothing beyond that: it doesn't mention pagination behavior (limit/offset are visible in the schema but unmentioned), result volume, or how the overview page is composed. The developer.ui.com URL is metadata, not 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?

It is short, but short by omission rather than by discipline. The second clause is a raw documentation URL that consumes roughly half the text without helping an agent decide or invoke, while the mechanically important pagination/filter semantics are absent.

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 only annotation-level safety hints, the description should describe what a "site overview page" returns and how to page through it. It does not, nor does it disambiguate from the many other listing siblings. Only the read-only/idempotent annotations keep this from being a full failure.

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 all three parameters, so the description carries the full burden and provides nothing. It never explains what 'filter' accepts (syntax, fields, operators) or how limit/offset pagination behaves, which is the single most important thing an agent needs here.

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

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

It states a verb and resource ("List Local Sites"), which is better than a tautology, but the name says "getsiteoverviewpage" (a paginated overview endpoint) while the description says "List", and no sibling is distinguished. Dozens of siblings perform similar listing (unifi_gen_listsites, unifi_net_list_sites, unifi_sm_list_sites), so an agent cannot tell which one to pick from this text.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as unifi_gen_listsites or unifi_net_list_sites. The only extra content is a provenance URL, which gives the agent nothing actionable about selection.

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