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

With no annotations, the description carries full burden. 'Adopt' implies a write/mutation operation that likely changes device state, but it doesn't disclose behavioral traits such as required permissions, whether it's idempotent, potential side effects, or error conditions. This leaves significant gaps for an agent to understand the tool's behavior.

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

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

The description is extremely concise with a single sentence, 'Adopt a pending device', which is front-loaded and wastes no words. Every word earns its place, making it efficient for quick understanding.

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

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

Given the complexity of a device adoption tool (likely a mutation with administrative impact), no annotations, and no output schema, the description is incomplete. It lacks details on behavior, outcomes, or error handling, leaving the agent with insufficient context for safe and effective use.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (siteId and deviceId). The description doesn't add any meaning beyond what the schema provides, such as explaining where to find these IDs or their format. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Adopt a pending device' clearly states the action (adopt) and target (pending device), but it's somewhat vague about what 'adopt' means operationally. It doesn't differentiate from siblings like 'unifi_get_device' or 'unifi_list_pending_devices', though the verb 'adopt' suggests a distinct administrative action.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., that the device must be in a pending state, which might be inferred from 'pending device' but isn't explicit) or refer to sibling tools like 'unifi_list_pending_devices' for context.

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

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

No annotations are provided, so the description carries full burden. It states the action ('Authorize') which implies a write/mutation operation, but doesn't disclose behavioral traits like required permissions, whether authorization is reversible, rate limits, or what happens upon success/failure. For a tool that grants network access, this is a significant gap in safety and operational context.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized for a straightforward authorization tool and front-loads the essential information without unnecessary elaboration.

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

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

Given this is a mutation tool (authorization implies write access) with no annotations and no output schema, the description is incomplete. It doesn't address what the tool returns, error conditions, or important behavioral aspects like whether the authorization is immediate or requires additional steps. For a 6-parameter tool that controls network access, more context is needed.

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

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

Schema description coverage is 100%, with all 6 parameters well-documented in the schema (including ranges for numeric limits). The description adds no parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in description.

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

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

The description clearly states the action ('Authorize') and target ('a guest client on a hotspot network'), providing a specific verb+resource combination. It distinguishes from siblings like 'unifi_create_voucher' or 'unifi_get_client' by focusing on authorization rather than creation or retrieval. However, it doesn't explicitly differentiate from potential similar tools like network access controls.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing clientId from 'unifi_get_client'), exclusions, or complementary tools. With many sibling tools for network management, this lack of contextual guidance leaves the agent to infer usage scenarios independently.

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

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

With no annotations provided, the description carries full burden. It states this is a deletion operation but doesn't disclose critical behavioral traits: whether this is reversible, what permissions are required, if there are rate limits, or what happens on success/failure. The example filter helps but doesn't cover behavioral risks.

Agents need to know what a tool does to the 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 sentence is appropriately concise and front-loaded with the core action. The parenthetical example is useful but could be slightly more structured. No wasted words.

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

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

For a destructive bulk operation with no annotations and no output schema, the description is insufficient. It doesn't cover what happens after deletion, error conditions, or important constraints. The example helps but doesn't compensate for missing behavioral 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 100%, so the baseline is 3. The description adds minimal value by providing a filter example ('expired.eq(true)'), but doesn't explain parameter relationships or additional semantics beyond what's in the schema.

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

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

The description clearly states the verb ('bulk delete') and resource ('hotspot vouchers'), and specifies the action is based on filter criteria. It distinguishes from sibling 'unifi_delete_voucher' by emphasizing bulk operations with filtering.

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

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

No explicit guidance on when to use this tool versus alternatives like 'unifi_delete_voucher' or 'unifi_list_vouchers'. The description mentions filter criteria but doesn't provide context about when bulk deletion is appropriate versus individual deletion.

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

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

With no annotations provided, the description carries full burden but only states it 'creates' without disclosing behavioral traits. It doesn't mention permissions required, whether the rule takes effect immediately, potential side effects on network traffic, or error conditions. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a straightforward creation tool and front-loads the essential action and resource.

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

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

Given this is a mutation tool with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what happens after creation (e.g., success response, rule ID returned), error handling, or how it interacts with sibling tools like 'unifi_list_acl_rules'. The minimal description fails to compensate for the lack of structured metadata.

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

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

The schema description coverage is 100%, providing clear documentation for all 8 parameters including enums for 'type' and 'action'. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline score of 3 where the schema does the heavy lifting.

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

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

The description clearly states the verb ('create') and resource ('new ACL (firewall) rule'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'unifi_create_firewall_zone' or 'unifi_create_traffic_matching_list', which also create related firewall components.

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

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

No guidance is provided about when to use this tool versus alternatives like 'unifi_update_acl_rule' for modifications or 'unifi_get_acl_rule' for retrieval. The description lacks context about prerequisites, such as needing an existing site, or when ACL rules are appropriate versus other firewall mechanisms.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a firewall zone but doesn't explain what that entails—such as whether it requires admin permissions, if it affects network traffic immediately, potential side effects, or error conditions. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the key action ('Create') and resource ('firewall zone'), making it easy to parse. Every word earns its place, and there's no redundancy or fluff.

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

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

Given the tool's complexity (a mutation operation with no annotations and no output schema), the description is incomplete. It doesn't cover behavioral aspects like permissions, side effects, or error handling, and it lacks usage guidelines. While the schema handles parameters well, the overall context for safe and effective use is insufficient, especially for a creation tool in a network management system.

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

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

The input schema has 100% description coverage, clearly documenting all three required parameters (siteId, name, networkIds). The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, though the description doesn't compensate for any gaps.

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

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

The description clearly states the action ('Create') and resource ('new custom firewall zone'), making the purpose immediately understandable. It distinguishes this tool from sibling tools like 'unifi_get_firewall_zone' and 'unifi_update_firewall_zone' by specifying creation rather than retrieval or modification. However, it doesn't explicitly differentiate from other creation tools (e.g., 'unifi_create_network'), which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a site ID from 'unifi_list_sites'), when not to use it (e.g., if a zone already exists), or how it relates to sibling tools like 'unifi_update_firewall_zone' or 'unifi_delete_firewall_zone'. This lack of context leaves the agent to infer usage scenarios independently.

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

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

No annotations are provided, so the description carries full burden. 'Create a new network' implies a write operation, but it doesn't disclose behavioral traits like whether this requires admin permissions, if it's idempotent, what happens on failure, or if it affects existing network configurations. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to scan and understand the core purpose without unnecessary elaboration.

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

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

Given the complexity of creating a network (a mutation operation with 5 required parameters), no annotations, and no output schema, the description is incomplete. It lacks information about return values, error handling, side effects, and how it fits into the broader toolset, making it inadequate for safe and effective use by an AI agent.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters with descriptions and an enum for 'management'. The description adds no additional meaning beyond what the schema provides, such as explaining parameter interactions or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Create a new network' clearly states the action (create) and resource (network), but it's vague about what a 'network' entails in this context and doesn't distinguish it from sibling tools like 'unifi_create_wifi' or 'unifi_create_firewall_zone'. It provides basic purpose but lacks specificity about network types or scope.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'unifi_update_network' or 'unifi_get_network', nor does it mention prerequisites such as needing a site ID or when network creation is appropriate. There's no context about usage scenarios or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Create' implies a write operation, it doesn't specify whether this requires admin permissions, what happens on duplicate names, whether the creation is immediate or queued, or what error conditions might occur. For a creation tool with zero annotation coverage, this is inadequate.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a creation tool and gets straight to the point without unnecessary elaboration.

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

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

For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what a 'traffic matching list' is used for in UniFi, what happens after creation, whether there are size limits for items, or what the tool returns. Given the complexity of networking configuration and lack of structured behavioral information, more context is needed.

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

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

The schema has 100% description coverage, so all parameters are documented in the structured fields. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('Create') and resource ('traffic matching list'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'unifi_update_traffic_matching_list' or explain what a 'traffic matching list' is in the context of UniFi networking.

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

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

No guidance is provided about when to use this tool versus alternatives like 'unifi_update_traffic_matching_list' for modifications or 'unifi_delete_traffic_matching_list' for removal. The description lacks any context about prerequisites, timing considerations, or relationship to other networking tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Create hotspot vouchers' indicates a write operation but lacks details on permissions required, whether it's idempotent, rate limits, error conditions, or what happens on success (e.g., returns voucher codes). It doesn't address potential side effects like network access changes or system impacts.

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

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

The description is extremely concise with just three words, front-loading the core purpose without any fluff. Every word ('Create', 'hotspot', 'vouchers') earns its place by specifying the action and resource, making it efficient and easy to parse.

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

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

Given the tool's complexity (8 parameters, 3 required, no output schema, and no annotations), the description is incomplete. It doesn't explain the tool's role in the broader system (e.g., for guest Wi-Fi access), what the output looks like (voucher codes or confirmation), or behavioral aspects like error handling. For a creation tool with multiple parameters, more context is needed to guide effective use.

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

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

The description adds no parameter semantics beyond the input schema, which has 100% coverage with clear descriptions for all 8 parameters (e.g., timeLimitMinutes range, count default). Since schema_description_coverage is high, the baseline is 3—the description doesn't compensate but doesn't need to, as the schema adequately documents 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 'Create hotspot vouchers' clearly states the action (create) and resource (hotspot vouchers), which is specific and unambiguous. It distinguishes from siblings like unifi_get_voucher (read) and unifi_delete_voucher (delete), though it doesn't explicitly differentiate from other creation tools like unifi_create_network or unifi_create_wifi beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a site ID), compare to similar tools (e.g., unifi_authorize_guest for guest access), or specify scenarios where voucher creation is appropriate over other access methods. Usage is implied by the name but not explained.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Create' implies a write operation, the description doesn't address critical behavioral aspects: required permissions, whether this is a destructive operation that might affect existing configurations, rate limits, or what happens on success/failure. For a network configuration tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence that communicates the core purpose without unnecessary words. It's appropriately sized for a tool with good schema documentation and gets straight to the point. Every word serves a purpose in clarifying what the tool does.

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

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

For a network creation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address what the tool returns, error conditions, side effects, or system impacts. Given the complexity of WiFi network configuration and the lack of structured behavioral information, the description should provide more context about how this operation fits into the broader system and what outcomes to expect.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters with descriptions. The description adds no additional parameter information beyond what's in the schema - it doesn't explain relationships between parameters, provide examples, or clarify edge cases. With complete schema coverage, the baseline of 3 is appropriate as the description doesn't enhance parameter understanding but doesn't need to compensate for schema gaps.

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

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

The description clearly states the action ('Create') and resource ('new WiFi network (SSID)'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like unifi_update_wifi or unifi_delete_wifi, but the verb 'Create' implies a distinct operation from those. The description avoids tautology by specifying what's being created rather than just restating the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like unifi_update_wifi and unifi_delete_wifi available, there's no indication of prerequisites, appropriate contexts, or when other tools might be more suitable. The agent must infer usage solely from the tool name and description without explicit direction.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Delete' which implies a destructive mutation, but doesn't specify if this action is reversible, requires admin permissions, has side effects (e.g., on network traffic), or provides confirmation. For a destructive tool, this lack of detail is a significant gap in transparency.

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

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

The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action ('Delete an ACL rule'), making it immediately clear. This is an example of optimal conciseness for a simple 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 mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects like permissions, irreversibility, or error conditions, nor does it hint at the response format. Given the tool's complexity (deletion) and lack of structured data, the description should provide more context to be fully helpful.

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

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

The input schema has 100% description coverage, with clear parameter names and descriptions ('Site ID', 'ACL rule ID'). The description doesn't add any semantic context beyond what the schema provides, such as how to obtain these IDs or their format. Given the high schema coverage, a baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('Delete') and resource ('an ACL rule'), making the purpose immediately understandable. It distinguishes itself from siblings like 'unifi_create_acl_rule' and 'unifi_update_acl_rule' by specifying deletion. However, it doesn't explicitly mention what an ACL rule is or its scope (e.g., network security), which keeps it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing ACL rule ID), when not to use it (e.g., if the rule is in use), or refer to sibling tools like 'unifi_get_acl_rule' for verification. This leaves the agent without context for proper 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?

With no annotations provided, the description carries full burden but only states the action ('Delete') without disclosing critical behavioral traits. It doesn't mention that this is a destructive operation, potential impacts on network security, required permissions, error conditions, or what happens upon success/failure.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple delete operation and front-loads the core action clearly.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It lacks information about behavioral consequences, error handling, or what the tool returns. Given the complexity of firewall zone deletion and absence of structured safety hints, more context is needed.

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

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

Schema description coverage is 100%, with both parameters ('siteId' and 'firewallZoneId') documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage.

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

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

The description clearly states the action ('Delete') and target resource ('a custom firewall zone'), providing specific verb+resource pairing. However, it doesn't differentiate from sibling tools like 'unifi_delete_acl_rule' or 'unifi_delete_network' beyond the resource type, missing explicit distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing the zone ID from 'unifi_list_firewall_zones'), exclusions, or comparisons with related tools like 'unifi_update_firewall_zone' or 'unifi_get_firewall_zone'.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Delete' implies a destructive mutation, but the description doesn't mention permissions required, whether deletion is reversible, what happens to dependent resources, or what the response looks like. This is inadequate for a destructive operation.

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

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

The description is extremely concise at just three words, with zero wasted language. It's front-loaded with the essential action and resource, making it immediately understandable despite its brevity.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain the implications of deletion, what 'cascade' or 'force' parameters mean in practice, or what happens after deletion. The agent lacks critical context for safe operation.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter information beyond what's in the schema, which is acceptable given the comprehensive schema coverage.

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

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

The description clearly states the action ('Delete') and resource ('a network'), making the purpose immediately understandable. It doesn't specifically differentiate from sibling deletion tools like 'unifi_delete_acl_rule' or 'unifi_delete_wifi', but the resource type is clear enough for basic understanding.

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

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

No guidance is provided about when to use this tool versus alternatives. While the name implies it's for network deletion, there's no mention of prerequisites, consequences, or relationships with other tools like 'unifi_get_network_references' that might be needed first.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. 'Delete' implies a destructive mutation, but it doesn't disclose whether this requires admin permissions, if deletion is permanent/reversible, what happens to dependent rules, or typical error cases. The description adds no context beyond the basic action.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and appropriately sized for a simple delete 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 mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'traffic matching list' means in context, the impact of deletion, required permissions, or what the tool returns. Given the complexity of network management tools, more contextual guidance is needed.

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

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

Schema description coverage is 100%, with both parameters ('siteId', 'trafficMatchingListId') clearly documented in the schema. The description adds no additional parameter context beyond what the schema provides, so the baseline score of 3 is appropriate given the schema does the heavy lifting.

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

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

The description clearly states the action ('Delete') and the resource ('a traffic matching list'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'unifi_delete_acl_rule' or 'unifi_delete_firewall_zone', but the specificity of 'traffic matching list' provides inherent distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing traffic matching list), consequences of deletion, or relationships with sibling tools like 'unifi_get_traffic_matching_list' for verification or 'unifi_create_traffic_matching_list' for recreation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive mutation, but the description doesn't specify whether this action is reversible, requires specific permissions, has side effects (e.g., affecting connected users), or provides confirmation feedback. This leaves critical behavioral traits undocumented for a destructive operation.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the essential action and resource, making it highly efficient. Every word earns its place, and there's no unnecessary elaboration or redundancy.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., irreversibility, permissions), usage context (e.g., when to use vs. bulk deletion), and expected outcomes (e.g., success confirmation or error messages). This leaves significant gaps for an AI agent to safely and effectively invoke the tool.

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

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

The input schema has 100% description coverage, with both parameters ('siteId' and 'voucherId') documented as 'Site ID' and 'Voucher ID' respectively. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or relationships between parameters. Given the high schema coverage, a baseline score of 3 is appropriate.

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

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

The description 'Delete a hotspot voucher' clearly states the action (delete) and the resource (hotspot voucher), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'unifi_bulk_delete_vouchers' or 'unifi_get_voucher', but the verb 'delete' is specific enough to convey the core function.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing voucher), contrast with 'unifi_bulk_delete_vouchers' for multiple deletions, or specify error conditions. Without such context, the agent must infer usage 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?

No annotations are provided, so the description carries full burden. 'Delete a WiFi network' implies a destructive mutation, but it doesn't disclose behavioral traits like whether deletion is permanent, requires admin permissions, affects connected devices, or has rate limits. The description is minimal and lacks critical context for a destructive operation.

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

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

The description is a single, direct sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse. No unnecessary words or redundant information are present.

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

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

Given the tool's complexity (destructive delete operation with 3 parameters) and lack of annotations or output schema, the description is inadequate. It doesn't cover behavioral aspects, error conditions, or output expectations. For a mutation tool with no structured safety hints, more context is needed to ensure safe and correct usage.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the input schema (siteId, wifiBroadcastId, force). The description adds no additional meaning beyond the schema, such as explaining parameter relationships or usage examples. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description 'Delete a WiFi network' clearly states the action (delete) and resource (WiFi network) with a specific verb. It distinguishes from sibling tools like 'unifi_create_wifi' and 'unifi_get_wifi' by indicating deletion rather than creation or retrieval. However, it doesn't specify scope or constraints beyond the basic action.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing siteId and wifiBroadcastId), consequences of deletion, or when to use 'force' parameter. With siblings like 'unifi_delete_network' and 'unifi_delete_voucher', there's no differentiation in 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read operation ('Get') but doesn't disclose authentication requirements, rate limits, error conditions, or what happens if the rule doesn't exist. The description is too basic for a tool that likely interacts with network security settings.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple retrieval operation and front-loads the core purpose immediately.

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

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

For a tool with no annotations and no output schema, the description is insufficient. It doesn't explain what information the ACL rule contains, the format of the returned data, or potential error responses. Given this is a network security tool in a complex system, more context about the rule structure or typical use cases would be helpful.

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

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

Schema description coverage is 100%, with both parameters ('siteId' and 'aclRuleId') clearly documented in the schema. The description mentions 'by ID' which aligns with 'aclRuleId' but adds no additional meaning beyond what the schema already provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description 'Get a specific ACL rule by ID' clearly states the verb ('Get') and resource ('ACL rule'), and specifies it's for a specific rule identified by ID. However, it doesn't differentiate from sibling tools like 'unifi_list_acl_rules' or 'unifi_update_acl_rule' beyond the basic operation type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'unifi_list_acl_rules' for listing multiple rules or 'unifi_update_acl_rule' for modifications, nor does it specify prerequisites like needing to know the rule ID beforehand.

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

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

No annotations are provided, so the description carries full burden. It states a read operation ('Get'), which implies it's non-destructive, but doesn't disclose behavioral traits like authentication requirements, rate limits, error handling, or what data is returned. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for a simple retrieval tool, making it easy to parse quickly.

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

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

Given the tool's low complexity (2 required parameters, 100% schema coverage) and lack of output schema, the description is minimally adequate. It states what the tool does but lacks context on return values, error cases, or system behavior. With no annotations, it should provide more behavioral details to be fully complete.

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

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

The schema description coverage is 100%, with both parameters ('siteId' and 'clientId') clearly documented in the schema. The description adds no additional meaning beyond implying these IDs are needed, so it meets the baseline of 3 where the schema does the heavy lifting without extra value from the description.

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

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

The description clearly states the action ('Get') and target ('a specific client by ID'), making the purpose understandable. It distinguishes from the sibling 'unifi_list_clients' by specifying retrieval of a single client rather than listing multiple. However, it doesn't specify what a 'client' represents in the UniFi context (e.g., network client/device).

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The description implies usage when you need a specific client by ID, but it doesn't mention prerequisites (e.g., needing site ID) or compare with 'unifi_list_clients' for broader queries. Usage is implied rather than explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a read operation ('Get'), but doesn't mention whether this requires specific permissions, what happens if the device doesn't exist, rate limits, or what the response format looks like. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that states the core purpose without any wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information. Every word earns its place.

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

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

For a simple read operation with 2 required parameters and 100% schema coverage, the description covers the basic purpose adequately. However, with no annotations and no output schema, it should ideally provide more behavioral context about what the tool returns and any constraints. The description is minimally viable but leaves gaps in usage guidance and behavioral transparency.

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

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

The schema description coverage is 100%, with both parameters clearly documented in the schema. The description adds no additional parameter information beyond what's already in the schema. According to the scoring rules, when schema coverage is high (>80%), the baseline score is 3 even with no parameter details in the description.

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

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

The description clearly states the verb 'Get' and the resource 'a specific device by ID', making the purpose immediately understandable. It distinguishes from sibling tools like 'unifi_list_devices' by specifying retrieval of a single device rather than listing multiple devices. However, it doesn't explicitly differentiate from other get tools like 'unifi_get_device_statistics' or 'unifi_get_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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over 'unifi_list_devices' for bulk retrieval or 'unifi_get_device_statistics' for performance data. There are no prerequisites, exclusions, or context about authentication requirements or error conditions.

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

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

No annotations are provided, so the description carries full burden. It states 'Get' implying a read operation, but doesn't disclose behavioral traits like authentication requirements, rate limits, data freshness ('latest' is vague), error conditions, or response format. For a tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose and appropriately sized for a simple read 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 tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'statistics' includes (e.g., performance metrics, usage data), how data is returned, or any prerequisites. Given the complexity of device statistics and lack of structured fields, more context is needed.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description adds no additional meaning about the parameters beyond implying they identify a device. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get') and resource ('latest statistics for a device'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'unifi_get_device' or 'unifi_list_devices', which might provide different types of device 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?

No guidance is provided on when to use this tool versus alternatives. With siblings like 'unifi_get_device' (likely general device info) and 'unifi_list_devices' (likely device listing), the description offers no context for choosing this specific statistics-focused tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but doesn't mention authentication requirements, rate limits, error handling, or the format of returned data. This leaves significant gaps in understanding how the tool behaves 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?

The description is a single, clear sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and efficiently conveys the essential information, making it easy to parse quickly.

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

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

Given the lack of annotations and output schema, the description is insufficient for a retrieval tool. It doesn't explain what data is returned, potential errors, or how it integrates with sibling tools like 'unifi_list_firewall_zones'. For a tool that likely returns structured data, more context is needed to use it effectively.

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

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

The input schema has 100% description coverage, clearly documenting both required parameters ('siteId' and 'firewallZoneId'). The description adds no additional semantic information beyond what the schema provides, such as explaining what these IDs represent or how to obtain them, so it meets the baseline for adequate but not enhanced parameter understanding.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('a specific firewall zone by ID'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from its sibling 'unifi_list_firewall_zones', which might retrieve multiple zones, leaving some ambiguity about when to use one versus the other.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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_list_firewall_zones' for listing multiple zones or other retrieval tools. It lacks context about prerequisites, error conditions, or typical use cases, offering minimal assistance in 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?

No annotations are provided, so the description carries full burden. It states it 'gets' information, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, error conditions, or whether it returns structured data. This is a significant gap for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that front-loads the purpose ('Get application information') and specifies key details ('including version and whether it's a UniFi OS Console'). Every word earns its place with no redundancy or fluff.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It covers the purpose but lacks behavioral context (e.g., what the output looks like, any side effects), which is important since no annotations or output schema exist to fill in those details.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the absence of inputs. The description doesn't need to add parameter details, and it doesn't contradict the schema. Baseline is 4 for zero parameters, as no compensation is needed.

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

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

The description clearly states the verb 'Get' and the resource 'application information', specifying the content includes 'version and whether it's a UniFi OS Console'. It distinguishes from siblings by focusing on system-level metadata rather than device/network operations, though it doesn't explicitly contrast with other 'get' tools like unifi_get_device or unifi_get_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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites, context (e.g., for setup or diagnostics), or when other tools might be more appropriate, such as for detailed device info versus system info.

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

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

No annotations are provided, so the description carries the full burden. It states 'Get' which implies a read-only operation, but doesn't disclose behavioral traits like authentication requirements, error handling, rate limits, or what data is returned. This is a significant gap for a tool with no annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what a 'network' entails in this context, what data is returned, or any prerequisites like needing to list sites or networks first. For a tool with two required parameters and no structured output info, more context is needed.

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

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

The schema description coverage is 100%, with both parameters ('siteId' and 'networkId') documented in the schema. The description adds no additional meaning beyond implying these IDs are needed to fetch a network, so it meets the baseline of 3 without compensating for any schema gaps.

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

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

The description clearly states the action ('Get') and resource ('a specific network by ID'), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like 'unifi_list_networks' or 'unifi_get_network_references', but the specificity of 'by ID' implies a single retrieval versus listing.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention using 'unifi_list_networks' to find network IDs first or clarify that this is for retrieving details of a known network, leaving the agent to infer usage from context.

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

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

With no annotations provided, the description carries full burden but only states what the tool does without behavioral details. It doesn't disclose if this is a read-only operation, what permissions are needed, error conditions, or response format. The description adds minimal context beyond the basic action.

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

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

The description is a single, efficient sentence that front-loads the core purpose with illustrative examples. Every word earns its place, making it easy to parse quickly without unnecessary elaboration.

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

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

For a read operation with 2 parameters and 100% schema coverage but no output schema, the description is adequate but incomplete. It explains what the tool does but lacks details on return values, error handling, or behavioral constraints, which are important given the absence of annotations.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 without compensating or enhancing parameter understanding.

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

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

The description clearly states the verb 'Get' and the resource 'references to a network', with specific examples like 'WiFi broadcasts, firewall zones, etc.' that illustrate what references are. It distinguishes from siblings like 'unifi_get_network' by focusing on references rather than network details, but doesn't explicitly name alternatives.

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

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

The description implies usage when needing to know what uses a network, but doesn't specify when to use this versus alternatives like 'unifi_get_network' or 'unifi_list_networks'. No explicit exclusions or prerequisites are mentioned, leaving usage context somewhat vague.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), which implies it's non-destructive, but doesn't mention authentication requirements, rate limits, error conditions, or what happens if the ID doesn't exist. This leaves significant gaps for a tool that presumably interacts with network infrastructure.

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

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

The description is a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately front-loaded with the essential information.

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

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

For a tool that retrieves specific network configuration objects with no annotations and no output schema, the description is insufficient. It doesn't explain what a 'traffic matching list' is, what information it returns, or provide any context about the Unifi system it operates within. The agent would need to guess about the return format and system 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?

The input schema has 100% description coverage, with both parameters clearly documented as 'Site ID' and 'Traffic matching list ID'. The description doesn't add any meaningful semantic context beyond what the schema already provides, such as explaining what these IDs represent or where to find them.

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

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

The description clearly states the action ('Get') and the resource ('a specific traffic matching list by ID'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'unifi_list_traffic_matching_lists', which would retrieve multiple lists rather than a specific one.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention the sibling 'unifi_list_traffic_matching_lists' for retrieving multiple lists, nor does it explain prerequisites like needing to know the specific ID beforehand.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, the description doesn't clarify if this requires authentication, what happens if the voucher doesn't exist (e.g., error handling), or the format of the returned data. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and safety profile.

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

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

The description is a single, clear sentence: 'Get a specific hotspot voucher by ID'. It's front-loaded with the core action and resource, with no wasted words or unnecessary details. This makes it easy to parse and understand quickly, earning a top score for 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?

Given the tool's low complexity (2 required parameters, no nested objects) and high schema coverage, the description is adequate but not fully complete. It lacks output schema information, and with no annotations, it doesn't cover behavioral aspects like error handling or authentication needs. For a simple read operation, it meets minimum viability but could benefit from more context about the return format or usage scenarios.

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

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

The input schema has 100% description coverage, with both parameters ('siteId' and 'voucherId') clearly documented in the schema. The description mentions 'by ID' which aligns with 'voucherId', but adds no additional semantic context beyond what the schema provides. According to the rules, with high schema coverage, the baseline is 3, as the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the tool's purpose: 'Get a specific hotspot voucher by ID'. It specifies the verb ('Get'), resource ('hotspot voucher'), and identifier ('by ID'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'unifi_list_vouchers' or 'unifi_create_voucher', which would require mentioning it retrieves a single voucher rather than listing or creating them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'unifi_list_vouchers' for listing multiple vouchers or 'unifi_create_voucher' for creating new ones, nor does it specify prerequisites such as needing an existing voucher ID. Without this context, users might struggle to choose the right tool for their needs.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'Get' but doesn't clarify if this is a read-only operation, what permissions are required, or the response format. No information on error handling, rate limits, or side effects is included, leaving significant gaps for a tool that likely interacts with network configurations.

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

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

The description is a single, direct sentence that efficiently conveys the core function without unnecessary words. It is front-loaded with the essential action and resource, making it easy to parse quickly. Every part of the sentence serves a clear purpose.

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

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

Given the lack of annotations and output schema, the description is insufficient for a tool that retrieves network configurations. It doesn't explain what data is returned (e.g., SSID, security settings), potential errors, or dependencies. For a read operation in a system with many sibling tools, more context is needed to ensure proper use.

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

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

The schema description coverage is 100%, with both parameters ('siteId' and 'wifiBroadcastId') documented in the schema. The description adds no additional meaning beyond implying these IDs are needed to fetch a specific network, which is already clear from the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Get') and resource ('specific WiFi network by ID'), making the purpose unambiguous. It distinguishes from sibling tools like 'unifi_list_wifi' by specifying retrieval of a single network rather than listing multiple. However, it doesn't explicitly mention what 'get' entails (e.g., fetching configuration 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?

No guidance is provided on when to use this tool versus alternatives. While the description implies it's for retrieving a specific WiFi network, it doesn't contrast with 'unifi_list_wifi' for bulk retrieval or 'unifi_get_network' for other network types. There are no prerequisites, exclusions, or context for selection 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'List all ACL (firewall) rules at a site', which implies a read-only operation, but doesn't specify permissions required, pagination behavior (beyond what the schema hints at with offset/limit), rate limits, or what the output format looks like. This leaves significant gaps for a tool with no 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?

The description is a single, clear sentence that efficiently states the tool's purpose without any wasted words. It's front-loaded with the core action ('List all ACL (firewall) rules at a site'), making it easy to parse quickly.

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

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

Given the tool's complexity (a list operation with pagination and filtering), lack of annotations, and no output schema, the description is minimally adequate but incomplete. It covers the basic purpose but fails to address behavioral aspects like permissions, rate limits, or output format, which are crucial for effective use. The schema handles parameters well, but overall context is lacking.

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

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

The schema description coverage is 100%, so the schema already documents all four parameters (siteId, offset, limit, filter) with descriptions. The description doesn't add any additional meaning beyond what the schema provides, such as explaining the filter expression format or typical use cases for offset/limit. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('all ACL (firewall) rules at a site'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'unifi_get_acl_rule' (which likely retrieves a single rule) or 'unifi_list_firewall_zones' (which lists different firewall entities), missing full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention when to choose 'unifi_list_acl_rules' over 'unifi_get_acl_rule' for single-rule retrieval or how it relates to other list tools like 'unifi_list_firewall_zones'. There's only an implied context of listing ACL rules at a site.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only list operation but doesn't disclose pagination behavior (offset/limit defaults), rate limits, authentication requirements, error conditions, or output format. For a tool with 4 parameters and no annotations, this leaves significant gaps in understanding how it behaves.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('List all connected clients') and includes essential qualifiers ('wired, wireless, VPN' and 'at a site') without waste. Every word earns its place, making it highly concise and well-structured.

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

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

Given the tool's moderate complexity (4 parameters, list operation), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the return format, pagination handling, error scenarios, or how it differs from similar list tools. For a tool that likely returns structured client data, more context is needed to guide effective use.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters (siteId, offset, limit, filter). The description adds no additional parameter semantics beyond implying 'site' context for siteId. Baseline 3 is appropriate when the schema does the heavy lifting, though the description doesn't compensate with extra context like filter expression examples.

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

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

The description clearly states the action ('List all connected clients') and specifies the resource scope ('at a site'), with additional detail about client types ('wired, wireless, VPN'). It distinguishes from siblings like 'unifi_get_client' (singular) and 'unifi_list_devices' (different resource), though not explicitly. However, it doesn't explicitly differentiate from all similar list tools, keeping it at 4 rather than 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'unifi_get_client' (for a specific client) or 'unifi_list_devices' (for hardware devices). It mentions the site context but doesn't explain prerequisites, exclusions, or comparative use cases with sibling tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool lists countries/regions with ISO codes and names, but doesn't describe pagination behavior (implied by offset/limit parameters), rate limits, authentication requirements, or what happens with the filter parameter. For a list tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that states the tool's purpose clearly without unnecessary words. It's appropriately sized for a simple list operation and front-loads the essential information.

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

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

For a list tool with 3 parameters (fully documented in schema) but no annotations and no output schema, the description provides basic purpose but lacks behavioral context. It doesn't explain what the output looks like (though no output schema exists), pagination behavior, or error conditions. This is minimally adequate but has clear gaps.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (offset, limit, filter) with their types and descriptions. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'List all countries/regions for geo-based rules (ISO codes and names)'. It specifies the verb ('List'), resource ('countries/regions'), and context ('for geo-based rules'), but doesn't explicitly differentiate from sibling tools like 'unifi_list_acl_rules' or 'unifi_list_networks' which have similar list patterns.

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

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

The description implies usage context ('for geo-based rules'), suggesting this tool is used when configuring geographic restrictions. However, it doesn't provide explicit guidance on when to use this versus other list tools or alternatives, nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden but only states it lists devices without disclosing behavioral traits. It omits details like pagination behavior (implied by offset/limit but not explained), rate limits, authentication needs, or what 'adopted' entails, leaving significant gaps for a list operation.

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

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

The description is a single, clear sentence with no wasted words, front-loading the core action and resource. It is appropriately sized for a straightforward list tool, making it efficient and easy to parse.

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

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

Given no annotations and no output schema, the description is minimal but covers the basic purpose. For a list tool with 4 parameters and 100% schema coverage, it's adequate but lacks depth on behavior (e.g., pagination, adoption context) and output format, leaving room for improvement in completeness.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no additional meaning beyond implying filtering by 'adopted' status, which aligns with the 'filter' parameter but doesn't elaborate. Baseline 3 is appropriate as the schema handles most 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 clearly states the action ('List') and resource ('all adopted devices at a site'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'unifi_list_pending_devices' or 'unifi_get_device', which list different device subsets or retrieve single devices, leaving some ambiguity in sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It lacks mention of prerequisites (e.g., site identification), exclusions (e.g., non-adopted devices), or comparisons to siblings like 'unifi_list_pending_devices' for pending devices, offering minimal usage context.

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

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

No annotations are provided, so the description carries the full burden. It mentions that tags are 'used for WiFi broadcast assignments,' which adds some behavioral context about their purpose, but it doesn't disclose critical traits like whether this is a read-only operation (implied by 'List'), potential side effects, authentication requirements, rate limits, or error handling. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core action ('List all device tags') and includes relevant context. There's no wasted verbiage, and it's appropriately sized for a simple list operation. However, it could be slightly more structured by explicitly separating purpose from usage, but this is minor.

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

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

Given the tool's complexity (a list operation with 4 parameters, no output schema, and no annotations), the description is minimally adequate. It covers the purpose and basic context but lacks details on output format, pagination behavior (implied by offset/limit), or how results relate to WiFi assignments. For a tool with no output schema, more information on return values would enhance completeness, but it's not entirely incomplete.

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

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

The input schema has 100% description coverage, so the schema fully documents all parameters (siteId, offset, limit, filter). The description doesn't add any additional semantic details beyond what's in the schema, such as examples or constraints not covered (e.g., format of filter expressions). With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the action ('List all device tags') and resource ('at a site'), with a specific purpose ('used for WiFi broadcast assignments'). It distinguishes from siblings like 'unifi_list_devices' by focusing on tags rather than devices themselves. However, it doesn't explicitly contrast with other list tools like 'unifi_list_wifi' or 'unifi_list_networks' that might also relate to WiFi configurations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 minimal usage guidance, only mentioning the context ('at a site') and a use case ('WiFi broadcast assignments'). It doesn't specify when to use this tool versus alternatives, such as whether it's for configuration, monitoring, or troubleshooting, or how it differs from other tag-related operations that might exist in the sibling set (though none are explicitly listed).

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool lists applications but doesn't disclose whether this is a read-only operation, requires authentication, has rate limits, returns paginated results, or what format the output takes. The description lacks details on performance, side effects, or error conditions that would help an agent use it correctly.

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

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

The description is a single, efficient sentence with no wasted words. It front-loads the core purpose ('List all DPI applications') and adds context ('for traffic identification and filtering') that clarifies the domain. Every part of the sentence contributes meaning, making it appropriately concise and well-structured.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 3 parameters. It lacks behavioral context (e.g., read-only nature, pagination behavior implied by offset/limit), output format details, and usage guidelines. While the schema covers parameters well, the description doesn't provide enough information for an agent to fully understand how to invoke and interpret results from 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%, with all parameters (offset, limit, filter) well-documented in the schema. The description adds no additional parameter semantics beyond implying filtering capability through 'traffic identification and filtering'. Since the schema already fully describes parameters, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the verb ('List') and resource ('all DPI applications') with a purpose ('for traffic identification and filtering'). It distinguishes from siblings like 'unifi_list_dpi_categories' by specifying applications rather than categories, but doesn't explicitly contrast with other list tools like 'unifi_list_acl_rules' or 'unifi_list_traffic_matching_lists' that might overlap in network management context.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing DPI enabled), exclusions, or comparisons to similar tools like 'unifi_list_traffic_matching_lists' or 'unifi_get_acl_rule' that might serve related purposes in network filtering. Usage is implied only by the tool name and description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but fails to mention pagination details (implied by offset/limit), rate limits, authentication needs, or what the output looks like. This leaves significant gaps for a tool with parameters.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any fluff. It's front-loaded and appropriately sized, making it easy to parse quickly.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with parameters. It doesn't explain behavioral aspects like pagination, filtering semantics, or return format, which are crucial for effective use. The schema covers parameters well, but overall context is lacking.

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

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

The input schema has 100% description coverage, so parameters are well-documented in the schema itself. The description adds no additional semantic context about the parameters (e.g., how 'filter' works with DPI categories). Baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('all DPI categories for traffic identification'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'unifi_list_dpi_applications' or other list tools, which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'unifi_list_dpi_applications' or other filtering/list tools. It lacks context about prerequisites, typical use cases, or exclusions, leaving the agent with minimal usage direction.

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

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

With no annotations provided, the description carries full burden but only states the basic operation. It doesn't disclose behavioral traits such as whether this is a read-only operation (implied by 'List' but not explicit), pagination behavior (though schema hints at offset/limit), rate limits, authentication requirements, or what the output format might be. The description adds minimal value beyond the name.

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

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

The description is a single, efficient sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (list operation with 4 parameters), no annotations, and no output schema, the description is minimally adequate but lacks completeness. It covers the basic purpose but omits behavioral context, usage guidelines, and output details, leaving gaps for an AI agent to infer behavior from the schema alone.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters (siteId, offset, limit, filter) with clear descriptions. The description adds no additional meaning about parameters beyond implying 'at a site' relates to siteId. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('List all') and resource ('firewall zones at a site'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'unifi_get_firewall_zone' (singular) or 'unifi_list_acl_rules', but the verb 'List all' implies a bulk retrieval operation versus a specific fetch.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'unifi_get_firewall_zone' for retrieving a single zone or 'unifi_list_acl_rules' for related firewall components, nor does it specify prerequisites or contextual constraints beyond the implied site 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List all networks at a site' implies a read-only operation, but it doesn't mention pagination behavior (offset/limit parameters), filtering capabilities, authentication requirements, rate limits, or what the output format looks like. This leaves significant gaps for an agent to understand how to use it effectively.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple list operation and gets straight to the point without unnecessary elaboration.

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

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

For a list operation with good schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks important context about authentication, pagination behavior, filtering capabilities, and output format that would help an agent use it correctly.

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

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

The input schema has 100% description coverage, providing clear documentation for all 4 parameters (siteId, offset, limit, filter). The description adds no additional parameter information beyond what's in the schema, so it meets the baseline score of 3 where the schema does the heavy lifting.

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

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

The description 'List all networks at a site' clearly states the verb ('List') and resource ('networks at a site'), making the purpose unambiguous. However, it doesn't differentiate from similar sibling tools like 'unifi_get_network' (which retrieves a specific network) or 'unifi_list_wifi' (which lists WiFi networks specifically), so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'unifi_list_networks' over 'unifi_get_network' (for a single network) or 'unifi_list_wifi' (for WiFi-specific networks), nor does it specify prerequisites like authentication or site selection context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the scope ('global, not site-specific') but lacks critical details such as whether this is a read-only operation, what permissions are required, how results are formatted, or if there are rate limits. For a list tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero waste—it directly states the tool's purpose and key constraint ('global, not site-specific'). Every word earns its place, making it appropriately sized and front-loaded.

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

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

Given the tool's moderate complexity (list operation with 3 optional parameters) and lack of annotations or output schema, the description is minimally adequate. It covers the core purpose and scope but omits behavioral details like response format or error handling, leaving gaps that could hinder an AI agent's effective use.

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

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

The input schema has 100% description coverage, with clear documentation for 'offset', 'limit', and 'filter' parameters. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score of 3 where the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('devices pending adoption'), making the purpose specific and understandable. It distinguishes this tool from siblings like 'unifi_list_devices' by specifying the 'pending adoption' scope, though it doesn't explicitly compare them.

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

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

The description implies usage context by noting 'global, not site-specific', which suggests this tool should be used for cross-site pending devices rather than per-site queries. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'unifi_list_devices' or 'unifi_get_device', nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a listing operation, implying read-only behavior, but doesn't clarify pagination behavior (implied by offset/limit parameters), authentication requirements, rate limits, error conditions, or what the output looks like. For a tool with 4 parameters and no output schema, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence that immediately conveys the core functionality. There's no wasted language, repetition, or unnecessary elaboration. It's appropriately sized for a straightforward listing tool and gets directly to the point.

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

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

For a listing tool with 4 parameters, no annotations, and no output schema, the description provides basic purpose but lacks important context. It doesn't explain what RADIUS profiles are, what information they contain, how results are structured, or behavioral aspects like pagination. While the schema covers parameters well, the overall context for effective tool use is incomplete.

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

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

The input schema has 100% description coverage, providing clear documentation for all 4 parameters (siteId, offset, limit, filter). The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('List all') and resource ('RADIUS profiles at a site'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'unifi_list_networks' or 'unifi_list_wifi', but the specific resource type (RADIUS profiles) provides inherent distinction. The description avoids tautology by not just restating the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing site access), compare it to similar listing tools (like 'unifi_list_networks'), or indicate when not to use it (e.g., for creating or updating RADIUS profiles). The agent must infer usage purely from the tool name and description.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool lists sites but doesn't describe return format (e.g., array of objects with fields), pagination behavior (implied by offset/limit but not explained), error conditions, or authentication requirements. The description adds no meaningful context beyond the basic purpose.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's front-loaded with the essential information ('List all sites'), making it easy to parse quickly.

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

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

For a list operation with no annotations and no output schema, the description is insufficient. It doesn't explain what data is returned (site fields, structure), how pagination works despite offset/limit parameters, or any API-specific behaviors. The agent lacks critical information to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (offset, limit, filter) with their types, defaults, and constraints. The description adds no parameter information beyond what's in the schema, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('List') and resource ('sites available to the API key'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'unifi_list_networks' or 'unifi_list_wifi' by specifying 'sites' as the resource. However, it doesn't explicitly differentiate from other list operations beyond the resource name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., API key scope), when this tool is appropriate versus other list tools, or any contextual constraints. The agent must infer usage 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?

With no annotations, the description carries full burden but only states the action. It lacks behavioral details such as whether this is a read-only operation, if it requires specific permissions, pagination behavior (implied by offset/limit but not explained), rate limits, or error handling.

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

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

The description is a single, efficient sentence that front-loads the core purpose with no wasted words. It directly communicates the tool's function without redundancy or unnecessary elaboration.

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

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

For a list tool with no annotations and no output schema, the description is minimally adequate. It covers what the tool does but lacks context on usage, behavioral traits, and output format, leaving gaps for an AI agent to infer missing details.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description adds no additional meaning beyond the schema, such as explaining 'traffic matching lists' context or filter usage. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('all traffic matching lists at a site'), specifying the scope with examples ('port groups, IP groups'). It distinguishes from siblings like unifi_get_traffic_matching_list (singular) and unifi_create_traffic_matching_list (creation).

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

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

No explicit guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over unifi_get_traffic_matching_list for single items or unifi_list_acl_rules for related lists, nor does it specify prerequisites like authentication or site access.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists vouchers but doesn't describe the return format (e.g., JSON array of voucher objects), pagination behavior (implied by offset/limit but not explained), authentication requirements, rate limits, or whether it's a read-only operation. This leaves significant gaps for an agent to understand how to interpret results.

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

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

The description is a single, efficient sentence that immediately conveys the core functionality without unnecessary words. It's appropriately sized and front-loaded, with zero wasted content.

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

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

Given the tool's moderate complexity (list operation with filtering/pagination), no annotations, and no output schema, the description is minimally adequate but incomplete. It identifies what the tool does but lacks behavioral context (return format, pagination details) and usage guidance, leaving the agent to infer these from parameter names 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 input schema has 100% description coverage, providing clear documentation for all 4 parameters (siteId, offset, limit, filter). The description doesn't add any parameter-specific details beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the action ('List all') and resource ('hotspot vouchers at a site'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'unifi_get_voucher' (which likely retrieves a single voucher) or 'unifi_bulk_delete_vouchers' (which performs a different action), missing full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'unifi_get_voucher' for single voucher retrieval or 'unifi_bulk_delete_vouchers' for deletion operations, nor does it specify prerequisites or contextual constraints for listing vouchers.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'List all VPN servers at a site', which implies a read-only operation, but doesn't cover critical aspects like pagination behavior (implied by offset/limit parameters), rate limits, authentication requirements, or what 'all' entails in terms of scope. This leaves significant gaps for a tool with multiple parameters.

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

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

The description is a single, direct sentence with no wasted words, making it easy to parse and front-loaded with the core action. Every word ('List all VPN servers at a site') contributes essential information without redundancy or fluff, earning a top score for 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 list tool with no annotations and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavioral traits (e.g., pagination, errors) and output format, which are important given the tool's complexity (4 parameters). The high schema coverage helps, but more context would improve completeness for agent invocation.

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

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

Schema description coverage is 100%, with clear documentation for all parameters (siteId, offset, limit, filter). The description doesn't add any semantic details beyond what the schema provides, such as explaining how 'filter' works or the implications of 'limit' defaults. Given the high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('List all') and resource ('VPN servers at a site'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'unifi_list_vpn_tunnels' or 'unifi_list_networks', which might also list VPN-related or site resources, so it falls short of a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'unifi_list_vpn_tunnels' and 'unifi_list_networks' that might overlap in context, there's no mention of specific use cases, prerequisites, or exclusions, leaving the agent to infer usage based on the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't disclose critical traits like authentication requirements, rate limits, error handling, pagination details (beyond what's in the schema), or what the output looks like. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that front-loads the core purpose without any wasted words. It's appropriately sized for a simple list tool, making it easy to parse quickly. Every word earns its place by specifying the resource and scope.

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

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

Given no annotations and no output schema, the description is incomplete for a tool with 4 parameters. It adequately states what the tool does but lacks context on behavioral aspects (e.g., safety, errors, output format) and usage guidelines. For a list operation in a complex system like UniFi, more detail would help an agent use it correctly without relying solely on 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%, so the input schema fully documents all parameters (siteId, offset, limit, filter). The description adds no additional meaning beyond implying 'siteId' is required for context, which is already clear from the schema. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the action ('List') and resource ('all site-to-site VPN tunnels at a site'), making the purpose immediately understandable. It distinguishes from siblings like 'unifi_list_vpn_servers' by specifying 'tunnels' rather than 'servers', though it doesn't explicitly contrast with other list tools. This is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a site ID), exclusions, or comparisons to other list tools (e.g., 'unifi_list_networks' or 'unifi_list_vpn_servers'). Usage is implied by the name and description alone, with no explicit context or alternatives provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't mention pagination behavior (handled by offset/limit), rate limits, authentication requirements, or what the output format looks like (e.g., JSON array of WAN objects).

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple list operation and earns its place efficiently.

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

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

For a list tool with no annotations and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavior (e.g., pagination, output format) and usage context. Given the 100% schema coverage, it's complete enough to understand inputs but not fully informative for an agent.

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

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

Schema description coverage is 100%, with all three parameters (siteId, offset, limit) clearly documented in the schema. The description doesn't add any meaning beyond the schema (e.g., explaining what a WAN interface is or how siteId relates to other tools), so it meets the baseline of 3.

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

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

The description clearly states the action ('List all') and resource ('WAN interfaces at a site'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling list tools like 'unifi_list_networks' or 'unifi_list_wifi', which follow similar patterns but target different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a site ID from 'unifi_list_sites'), exclusions, or comparisons to other list tools like 'unifi_list_networks' for different interface types.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't mention pagination details (implied by offset/limit), rate limits, authentication needs, or what the output looks like (e.g., format, fields). This leaves significant gaps for a tool with multiple parameters.

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

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

The description is a single, clear sentence with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to understand at a glance.

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

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

Given the tool has 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like pagination, filtering behavior, or output format, which are crucial for effective use. This is inadequate for a list tool with multiple operational parameters.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters (siteId, offset, limit, filter). The description adds no additional meaning beyond implying a site context, which is already covered by the schema. This meets the baseline of 3 when the schema handles parameter documentation effectively.

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

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

The description clearly states the verb ('List') and resource ('all WiFi broadcasts (SSIDs) at a site'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'unifi_get_wifi' or 'unifi_create_wifi', which would require more context about what distinguishes listing from getting or creating.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'unifi_get_wifi' and 'unifi_create_wifi', there's no indication of whether this is for bulk retrieval, filtered queries, or other specific contexts, leaving usage ambiguous.

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

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

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose permissions needed, rate limits, whether changes are reversible, or what happens if the device is offline, which is critical for a mutation tool.

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

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

The description is a single, efficient sentence with zero waste, front-loaded with the core action. Every word earns its place, making it easy to parse quickly.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., effects, errors), return values, or usage context, leaving gaps for an AI agent to operate safely.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no extra meaning beyond implying 'enabled' toggles the LED, which the schema already covers, meeting the baseline for high coverage.

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

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

The description clearly states the verb ('enable or disable') and resource ('locate function on a device'), specifying it controls the flashing LED. It distinguishes from siblings like 'unifi_get_device' or 'unifi_restart_device' by focusing on LED status, though it doesn't explicitly compare them.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., device must be online), exclusions, or related tools like 'unifi_get_device' for checking status, leaving usage context implied.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral disclosure. 'Power cycle' implies a disruptive action that will temporarily interrupt connectivity, but the description doesn't state this explicitly, nor does it mention permissions required, whether the action is reversible, expected duration, or error conditions. For a potentially disruptive operation, this is inadequate.

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

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

The description is a single, efficient sentence that communicates the core purpose immediately. There's no wasted verbiage or redundant information. It's appropriately sized for a straightforward 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 disruptive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'power cycle' entails behaviorally, what the expected outcome is, or any side effects. The agent must guess whether this is a safe operation and what results to expect.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no parameter-specific information beyond what's in the schema (siteId, deviceId, portIdx). The baseline score of 3 reflects adequate coverage through schema alone, with no additional value from the description.

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

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

The description clearly states the specific action ('Power cycle') on a specific resource ('a specific port on a device') with additional technical detail ('PoE restart'). It distinguishes from sibling tools like 'unifi_restart_device' by specifying port-level rather than device-level restart.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (like needing device/port identification first), when port cycling is appropriate versus device restart, or what problems it solves. The agent must infer usage from context 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?

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this requires admin permissions, causes downtime, is reversible, has rate limits, or what happens on failure. 'Restart' implies a mutation but lacks critical operational context.

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

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

The description is a single, efficient sentence with zero waste—'Restart a device' is front-loaded and appropriately sized for the tool's purpose. Every word earns its place, making it highly concise and well-structured.

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

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

Given no annotations, no output schema, and a mutation tool with potential side effects, the description is incomplete. It doesn't cover behavioral traits, error handling, or return values, leaving significant gaps for an AI agent to understand the tool's full context and implications.

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

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

Schema description coverage is 100%, so parameters 'siteId' and 'deviceId' are documented in the schema. The description adds no additional meaning beyond implying these IDs are needed to target a device, which is already clear from the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description 'Restart a device' clearly states the action (restart) and target (device), but it's vague about what type of device (network device like AP or switch) and doesn't distinguish from sibling tools like 'unifi_power_cycle_port' which also restarts but at port level. It avoids tautology but lacks specificity.

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

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

No guidance is provided on when to use this tool versus alternatives like 'unifi_power_cycle_port' or 'unifi_locate_device', nor any prerequisites such as device adoption status. The description implies usage for restarting but offers no context for selection among similar operations.

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

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

No annotations are provided, so the description carries full burden. 'Update' implies a mutation, but it doesn't disclose behavioral traits like required permissions, whether changes are reversible, error handling, or what happens to unspecified fields (partial vs. full updates). This leaves significant gaps for safe agent operation.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, though this brevity contributes to gaps in other dimensions.

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

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

Given the complexity of an update operation with 8 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address mutation risks, success/failure outcomes, or contextual usage, making it inadequate for safe agent invocation despite good schema coverage.

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

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

Schema description coverage is 100%, so the schema fully documents all 8 parameters with descriptions and enums. The description adds no additional parameter semantics beyond what's in the schema, resulting in a baseline score of 3 where the schema does the heavy lifting.

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

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

The description 'Update an ACL rule' clearly states the action (update) and resource (ACL rule), which is specific enough to understand the basic purpose. However, it doesn't differentiate from sibling tools like 'unifi_update_firewall_zone' or 'unifi_update_network' beyond the resource type, nor does it specify what aspects of an ACL rule can be updated.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing ACL rule ID), when not to use it, or how it relates to sibling tools like 'unifi_create_acl_rule' or 'unifi_delete_acl_rule' in a workflow.

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

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

No annotations are provided, so the description carries full burden. 'Update' implies mutation, but it doesn't disclose behavioral traits like required permissions, whether changes are reversible, rate limits, or what happens to unspecified fields. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It lacks crucial context like behavioral traits, usage guidelines, and output details, making it insufficient for safe and effective tool invocation.

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

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

Schema description coverage is 100%, so the schema already documents all 4 parameters. The description adds no additional meaning beyond what the schema provides, such as format examples or constraints. Baseline 3 is appropriate when the schema handles parameter documentation.

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

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

The description clearly states the action ('Update') and resource ('a firewall zone'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'unifi_create_firewall_zone' or 'unifi_get_firewall_zone' beyond the verb, missing specific scope details that would distinguish it.

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

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

No guidance is provided on when to use this tool versus alternatives. With siblings like 'unifi_create_firewall_zone', 'unifi_get_firewall_zone', and 'unifi_delete_firewall_zone', the description lacks context on prerequisites (e.g., existing zone) or exclusions, leaving usage ambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but provides almost none. 'Update an existing network' implies a mutation operation but doesn't disclose whether this requires specific permissions, whether changes are reversible, what happens to existing settings not mentioned, or any rate limits or side effects. For a mutation tool with zero annotation coverage, this is a critical gap.

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

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

The description is extremely concise at just three words. While it may be under-specified, it's not wordy or repetitive. Every word serves a purpose, and there's no wasted text or unnecessary elaboration.

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

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

For a mutation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'update' entails, what fields can be modified, what the expected response looks like, or any error conditions. The agent would need to infer too much from just the three-word description given the tool's complexity.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters with their types, constraints, and descriptions. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description 'Update an existing network' clearly states the verb (update) and resource (network), but it's vague about what aspects can be updated. It doesn't differentiate from sibling tools like unifi_update_acl_rule or unifi_update_wifi beyond the resource type, and doesn't specify whether this updates configuration, settings, or other attributes.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing to identify an existing network first), nor does it differentiate from similar update tools for other resources. There's no indication of when this should be used versus creating a new network or other network-related operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Update' implies a mutation operation, but the description doesn't specify required permissions, whether changes are reversible, potential side effects (e.g., impact on network traffic), or error handling. It lacks details on rate limits, authentication needs, or what the response might contain, leaving significant gaps for safe and effective use.

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

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

The description is a single, efficient sentence: 'Update a traffic matching list'. It's front-loaded with the core action and resource, with zero wasted words. This makes it easy to parse quickly, though its brevity contributes to gaps in other dimensions like guidelines and transparency.

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

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

Given the complexity of a mutation tool with 5 parameters and no annotations or output schema, the description is incomplete. It doesn't address behavioral aspects (e.g., safety, permissions), usage context, or what to expect after invocation. For a tool that modifies network configurations, more detail is needed to ensure reliable agent operation, making this inadequate overall.

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

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

The input schema has 100% description coverage, with each parameter documented (e.g., siteId, trafficMatchingListId, type with enum, name, items). The description adds no additional meaning beyond the schema, such as explaining the purpose of 'items' or how 'type' affects updates. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, but the description doesn't compensate or enhance understanding.

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

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

The description 'Update a traffic matching list' clearly states the action (update) and resource (traffic matching list), which is adequate. However, it doesn't differentiate from sibling tools like 'unifi_update_acl_rule' or 'unifi_update_firewall_zone' beyond the resource name, nor does it specify what aspects are updated (e.g., name, items, type). This makes it vague compared to more specific descriptions.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing traffic matching list from 'unifi_create_traffic_matching_list' or 'unifi_get_traffic_matching_list'), nor does it contrast with other update tools like 'unifi_update_network'. Without such context, an agent might misuse it or overlook necessary steps.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Update' implies a mutation operation, but the description doesn't disclose any behavioral traits such as required permissions, whether changes are reversible, potential side effects on connected devices, or error conditions. This leaves significant gaps for a mutation tool.

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

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

The description is a single, clear sentence that states exactly what the tool does with zero wasted words. It's appropriately sized for a straightforward update operation and is perfectly front-loaded with the essential information.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address what happens after the update, what values are returned, error handling, or important behavioral aspects. Given the complexity of updating network configurations and the lack of structured metadata, the description should provide more 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?

The schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any meaningful parameter semantics beyond what's already in the schema - it doesn't explain relationships between parameters, provide examples, or clarify usage patterns. The baseline score of 3 reflects adequate but minimal value addition.

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

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

The description clearly states the action ('Update') and resource ('existing WiFi network'), making the purpose immediately understandable. It distinguishes from sibling tools like 'unifi_create_wifi' and 'unifi_delete_wifi' by specifying it's for updates rather than creation or deletion. However, it doesn't specify what aspects of the WiFi network can be updated beyond the basic concept.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like needing an existing WiFi network to update, nor does it differentiate from similar tools like 'unifi_update_network' or explain when to use this versus creating a new WiFi network. The agent must infer usage 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.