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

With no annotations, the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not say whether aborting is destructive, whether the task can be resumed, what state the task is left in, or whether the call is idempotent on an already-finished task.

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

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

It is superficially short, but the brevity reflects under-specification rather than conciseness: a three-character phrase cannot front-load any useful information for an agent.

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

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

An output schema exists so return values need not be explained, but for a state-changing task operation the definition leaves the agent without guidance on usage, parameter sourcing, or side effects. Only the presence of the output schema keeps this above the minimum.

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

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

The single parameter task_id has 0% schema description coverage and the description adds no meaning — it does not say where the ID comes from (e.g., list_tasks) or what form it takes. One undocumented parameter with no compensating text.

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

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

"中止任务" (abort task) merely restates the tool name and title, adding no scope, target, or distinction from siblings like retry_task or list_tasks. It is a tautology rather than a description of what the tool actually does.

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

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

There is no indication of when to use this tool versus alternatives such as list_tasks (to find a task to abort) or retry_task (to re-run one). No prerequisites, exclusions, or context are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no permission requirements, no confirmation of what a mutation does, no side effects, no ordering relative to rules. A one-phrase restatement of the name is a total gap for a write 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 single phrase is free of padding, but this is under-specification rather than conciseness — it is far too short for an 11-parameter mutation tool. There is no front-loaded substance because there is no substance at all.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 11 parameters at 0% coverage and no annotations, the description should compensate heavily; it does not. The presence of an output schema excuses only the omission of return-value details, which is nowhere near enough here.

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

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

Schema description coverage is 0% across 11 parameters, and the description explains none of them. Fields like action, direction, protocol, src_addr/dst_addr, src_port/dst_port, interface, and time_range are all undocumented, with no accepted values (e.g. that action/direction/protocol are likely enum-like strings) given anywhere.

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

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

The description '添加 ACL 规则' is a direct restatement of the tool name/title in another language, adding no information beyond the identifier. It does not distinguish this tool from siblings list_acl_rules, delete_acl_rule, or toggle_acl_rule.

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

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

No guidance whatsoever on when to use this versus the other ACL tools, no prerequisites, no mention that an ACL rule typically needs a direction/interface/action context. An agent gets no help choosing among the ACL siblings.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about this being a privileged, security-sensitive mutation that grants access rights, requires authentication, or is not obviously reversible. It also fails to mention the default IP scope (0.0.0.0/0) or default 'admin' privilege group chosen at creation.

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

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

It is short, but short because it is under-specified rather than efficient; there is no front-loaded scope, no context, and nothing an agent can act on beyond the name. One useful sentence about privilege level and defaults would cost little and add a lot.

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

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

An output schema exists, so return values need not be explained, and the parameter schema is fully described. However, for a security-sensitive account-creation tool with zero annotations, the description omits entirely the risk profile, required authorization, and consequences of the default permission/IP values.

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

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

Schema description coverage is 100% and includes defaults for allowed_ip and permission, so the schema already documents all four parameters. The description adds no meaning beyond those fields, which puts it at the baseline for high-coverage schemas rather than above it.

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

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

The description is a direct restatement of the title/name ("Add Admin Account" / 添加管理员账号) with no additional detail. It does convey a verb+resource, but gives no way to distinguish it from sibling creation tools such as add_pppoe_account, add_vpn_account, or add_ip_speed_limit, nor does it say what an admin account 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?

There is no when-to-use guidance, no mention of prerequisites (existing list_admin_accounts, current credentials), and no exclusions. An agent must infer everything about when this tool is appropriate versus the many other account-creation siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about side effects, required permissions, precedence interactions with prio, or whether the rule is applied immediately. For a mutation tool with zero annotation coverage this is a total gap.

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

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

It is a single short phrase, but this is under-specification rather than conciseness; there is no front-loaded verb, scope, or effect. Brevity here is a liability, not an asset.

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

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

An output schema exists so return values need not be explained, but with 8 undocumented parameters, no annotations, and a one-line tautological description, the definition is completely inadequate for an agent to invoke this tool correctly.

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

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

Eight parameters with 0% schema description coverage, and the description adds no meaning for any of them (action, prio, app_protos, src_addrs, time_range, week, enabled, comment). An agent cannot tell what values 'action' or 'app_protos' accept.

Input schemas describe structure but not intent. Descriptions should explain 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 '添加应用协议控制规则' merely restates the tool name/title in another language; it is a tautology with no added detail about scope, effect, or what an 'app protocol rule' controls. It does not distinguish this tool from siblings like list_app_protocol_rules, delete_app_protocol_rule, or toggle_app_protocol_rule.

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

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

No when-to-use guidance, prerequisites, or alternative selection criteria are given. The sibling set contains list/delete/toggle variants, so routing guidance is genuinely needed here, but none is provided.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it says nothing about permissions required, whether an existing binding for the same MAC/IP is overwritten or rejected, or how the change takes effect. For a configuration-mutating operation this is a severe 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 phrase is short with no wasted words, but it is under-specified rather than concise — brevity here reflects missing content, not efficient communication.

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

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

An output schema exists so return values need not be explained, but for a mutating tool with zero annotation coverage, three undocumented parameters, and no stated preconditions or effects, the description is completely inadequate.

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

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

Three parameters (ip, mac, comment) with 0% schema description coverage and no format hints in the description. The agent gets no indication of expected IP/MAC syntax (e.g. dotted-quad vs CIDR, colon- vs hyphen-separated MAC) or the purpose of 'comment'.

Input schemas describe structure but not intent. Descriptions should explain 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 ('添加 ARP 绑定' / 'Add ARP binding') is a verbatim restatement of the tool name and title, adding no scope, target, or effect information. It is not misleading, but it is tautological and gives the agent nothing beyond what the identifier already conveys.

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

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

No guidance whatsoever on when to add a binding versus listing or deleting one, no prerequisites, and no mention of adjacent siblings such as add_dhcp_static_binding or list_arp_bindings. The agent must infer everything.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the rule takes effect immediately, how it interacts with conflicting existing limits, whether auth/admin rights are required, or that the operation is a persistent mutation. 'Add' implies creation but nothing else is stated.

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

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

The single six-word phrase is technically brief, but its brevity is under-specification rather than conciseness. Nothing useful is front-loaded because nothing beyond the title is present.

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

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

For a 6-parameter mutation with no annotations and 0% schema description coverage, the description is wholly inadequate. The only mitigating factor, that a return value needn't be explained because an output schema exists, does not compensate for the missing purpose, usage, and parameter information.

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

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

Schema description coverage is 0% across 6 parameters (mac, ip_addr, time_range, max_connections, enabled, comment), and the description supplies no parameter meaning at all. Critical details such as whether mac or ip_addr is the targeting key, the time_range format, and units/semantics of max_connections are entirely undocumented.

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

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

The description '添加连接数限制' is a direct restatement of the tool title 'Add Connection Limit' and adds nothing beyond the name. It does not distinguish this tool from its obvious siblings list_connection_limits and delete_connection_limit, nor does it describe the object being limited (per-MAC, per-IP, global).

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

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

No when-to-use guidance, no prerequisites, and no mention of the sibling list_connection_limits or delete_connection_limit. The agent gets no signal about when a limit versus another QoS/rate-limit tool (e.g. add_ip_speed_limit, add_mac_speed_limit) is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers nothing: no statement about what the domains string format is, whether the name must be unique, whether existing entries conflict, whether the operation is additive or overwrites, or what permissions are needed.

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

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

It is short, but this is under-specification rather than conciseness; a single tautological phrase carries no useful information for an agent deciding whether and how to call the tool.

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

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

With 0% schema coverage, no annotations, and a mutation tool requiring two mandatory parameters, the description is wholly inadequate. The presence of an output schema only removes the need to explain return values, not the need to explain inputs and behavior.

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

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

Schema description coverage is 0% across three parameters, and the description does not compensate at all. The critical ambiguity — whether 'domains' is a comma-separated list, newline-delimited, or a single domain — is left completely unresolved.

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

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

The description "添加自定义网址库" is a literal translation of the tool name 'add_custom_url_library', restating the title rather than specifying what the tool does. It gives no hint of how this differs from siblings like list_custom_url_library, delete_custom_url_library, or add_url_blacklist.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as add_url_blacklist or add_domain_blacklist, which occupy adjacent functional space. The agent must infer entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about authentication/credential handling (username/password are required), provider requirements, or whether a duplicate domain is rejected. This is a multi-parameter mutation with zero behavioral disclosure.

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

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

It is short, but this is under-specification rather than conciseness; the single phrase conveys no actionable information. Nothing is front-loaded because there is nothing substantive to front-load.

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

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

Although an output schema exists so return values need not be documented, the description leaves a 6-parameter, 4-required mutation with no annotations totally unexplained. It is far too thin for the complexity of the tool.

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

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

Schema description coverage is 0% across 6 parameters (domain, provider, username, password, enabled, interface), and the description adds no meaning for any of them. Critically, the expected format for 'provider' and 'domain' is left entirely unexplained, so the agent cannot populate them correctly.

Input schemas describe structure but not intent. Descriptions should explain 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 '添加 DDNS' (Add DDNS) merely restates the tool name add_ddns and title 'Add Ddns' in another language. It identifies no resource details, scope, or any distinguishing feature versus siblings like get_ddns_config, delete_ddns, or get_dynamic_dns_config.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives such as get_ddns_config or delete_ddns. An agent gets zero help deciding when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation (adding a binding) but says nothing about permissions required, whether it conflicts with an existing lease or binding, reversibility, or how the change takes effect. For a mutation tool with zero annotation coverage this is a notable gap.

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

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

A single short sentence, front-loaded with the action and resource, with no filler. It is concise, though a longer description was arguably warranted given the missing behavioral and parameter context.

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

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

An output schema exists so return values needn't be explained, but with no annotations and 0% schema coverage, the description should describe prerequisites, conflicts, and parameter formats. None of that is present, leaving an agent under-informed for a mutation 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 0% and there are 3 parameters. The IP-MAC 绑定 phrasing loosely maps to the ip and mac fields but adds no format guidance (e.g., MAC syntax like aa:bb:cc:dd:ee:ff, CIDR vs single IP), and the comment parameter is not mentioned at all. The description only marginally compensates for the coverage gap.

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

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

States a specific verb (添加/add) plus resource (DHCP 静态分配) and clarifies with parenthetical IP-MAC 绑定, so an agent can distinguish it from sibling list_dhcp_static_bindings and delete_dhcp_static_binding by the verb alone. Clear, though it doesn't explicitly reference the siblings it competes with.

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

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

No when-to-use context, no prerequisites (e.g., whether the IP must be inside the DHCP pool, whether a binding must exist first), and no mention of alternatives like list_dhcp_static_bindings or delete_dhcp_static_binding. The agent must infer when this is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says nothing: not whether the entry takes effect immediately, whether it requires a target user/group context, whether existing entries are merged or overwritten, nor any permission requirement. For a mutating add operation this is a total gap.

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

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

A single four-character phrase is not concise but under-specified; there is no structure, no front-loaded detail, and no information an agent can act on beyond the merest gesture at the resource type.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 five-parameter write tool with zero annotation coverage and zero schema descriptions, the description supplies none of the scoping, sequencing, or parameter-format information needed to call it correctly. An output schema exists, so return values need not be described, but everything else is missing.

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

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

Schema description coverage is 0% for five parameters, and the description adds no meaning for any of them. The format of domain_groups (the sole required field), the weekday bitmask syntax ('1234567'), the time_range format, and the roles of enabled/comment are all entirely undocumented.

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

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

The Chinese phrase '添加禁止娱乐网站' ("add prohibited entertainment websites") conveys a verb and an object, so an agent can infer it creates an entry restricting entertainment sites. However, it never names the resource the tool actually manages (a domain blacklist entry / domain group) and gives no differentiation from the very similar sibling add_url_blacklist, so the purpose is only vaguely aligned with 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?

There is no statement of when to use this tool, no prerequisites, and no mention of alternatives such as add_url_blacklist or list_domain_blacklist. The agent must guess from the name alone whether this is the right entry point for blocking domains.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. For a mutation tool it does not state whether the rule takes effect immediately, what permissions are required, what happens on conflict with an existing rule, or whether the change is reversible.

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

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

The description is a single short phrase with no wasted words, but that brevity reflects under-specification rather than conciseness. It is not front-loaded with any actionable detail because there is none.

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

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

For a 5-parameter write operation with zero annotation coverage and no schema descriptions, this description is wholly inadequate. The presence of an output schema does not compensate, since the agent still cannot determine how to invoke the tool correctly.

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

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

Schema description coverage is 0% across 5 parameters, and the description provides no parameter information at all. Fields like src_addr, interface (defaulting to 'wan2'), and enabled have non-obvious semantics that are left completely undocumented.

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

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

The description "添加域名分流规则" is a direct translation of the tool title 'Add Domain Forwarding Rule' and adds no information beyond the name. It states a verb and resource, but is effectively a tautological restatement with no scope or differentiation from siblings like add_port_forwarding_rule or add_acl_rule.

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

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

There is no guidance on when to use this tool versus the many sibling rule-creation tools (add_port_forwarding_rule, add_static_route, add_acl_rule, etc.), nor any mention of prerequisites or the existence of list_domain_forwarding_rules / delete_domain_forwarding_rule. Usage must be entirely inferred from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says nothing about permissions, idempotency, duplicate handling, side effects, or authentication requirements—significant gaps for a mutation tool that creates a new IP group.

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

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

The description is a single short phrase with no waste, but it is under-specified rather than appropriately concise. It front-loads the action but contains far too little information to guide correct invocation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 4 parameters with 0% schema coverage, no annotations, and an output schema that only covers returns, the description is completely inadequate. An agent would need to infer parameter meanings, usage conditions, and behavioral traits from nothing.

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

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

Schema description coverage is 0% for 4 parameters (name, comment, ip_list, ip_type). The description mentions 'IP address group' generically but provides no meaning, format, or constraints for any parameter, so it does not compensate for the schema's lack of documentation.

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

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

The description states a clear verb and resource: '添加 IP 地址分组' (Add IP address group). It is unambiguous about what the tool does, but it does not differentiate this tool from sibling add-operations such as add_mac_group, add_ip_speed_limit, or add_dhcp_static_binding.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, no prerequisites, and no context about scenarios. It only names the operation.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not say whether the rule takes effect immediately, whether an existing rule for the same IP is overwritten or rejected, what units upload_kbps/download_kbps use, whether the device requires a restart, or what permissions are needed.

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

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

It is short, but the brevity comes from under-specification rather than efficient packing of useful content. Nothing is front-loaded because there is nothing to load.

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

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

For a mutation tool with five parameters at 0% schema coverage and no annotations, this is completely inadequate. The output schema exists so return values need not be described, but that alone does not compensate for the missing input semantics and 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 0% across five parameters, and the description mentions none of them. It gives no meaning for ip_addr, upload_kbps, download_kbps, enabled, or comment, nor their units, ranges, or defaults.

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

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

The description '添加 IP 限速' is essentially a verbatim translation of the tool name 'add_ip_speed_limit', so it restates the name rather than adding information. It does imply a mutation on an IP-based rate limit, but says nothing about scope (per-host? per-group?), units, or what distinguishes it from add_mac_speed_limit beyond the noun.

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

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

No when-to-use, when-not-to-use, prerequisites, or references to alternatives such as list_ip_speed_limits or delete_ip_speed_limit. The agent must infer everything from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the rule takes effect immediately, what permissions are required, or that the 'action' field defaults to 'drop' (i.e., blocking traffic). For a security-policy mutation tool this is a serious gap.

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

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

The single short sentence is technically concise but is under-specification rather than economy of language. It is also the only Chinese text in an otherwise English tool catalog, which is a structural inconsistency.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, 0% parameter documentation, and a missing output schema, the description provides no completeness at all. An agent cannot determine what a MAC access-control entry does or how to populate the five fields.

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

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

Schema description coverage is 0% across 5 parameters, and the description compensates for none of it. The meaning of 'action' (drop vs allow), 'time_range' format ('00:00-23:59'), 'enabled', and 'comment' are all left entirely undocumented.

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

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

"添加 MAC 访问控制" (Add MAC access control) merely restates the tool name and title in Chinese. It specifies a verb and resource but adds no distinguishing detail beyond what the name already conveys, nor does it separate itself from siblings like list_mac_access_control or delete_mac_access_control.

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

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

No guidance whatsoever on when to use this tool versus list_mac_access_control or delete_mac_access_control. No prerequisites, no context about whether this applies to a terminal, group, or global policy.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether an existing group name is overwritten or rejected, not what permissions are needed, not whether the change is reversible. It simply restates the tool title.

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

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

It is a single short phrase with no wasted words, but this is under-specification rather than genuine conciseness for a mutation tool with three undocumented parameters. Nothing is front-loaded because nothing substantive is present.

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

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

An output schema exists, so return values need not be explained. However, for a write operation with zero annotations and zero parameter documentation, the description omits the behavioral and input-format context an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% for all three parameters. The description adds no meaning for 'name', 'comment', or the critical 'mac_list' field, whose expected format (comma-separated, one per line, ranges?) is completely undocumented in both schema and description.

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

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

The description states a specific verb plus resource ('添加' / add, 'MAC 地址分组' / MAC address group), so an agent can tell what object is being created. It does not explicitly distinguish itself from the sibling tools list_mac_groups or delete_mac_group, but the add/create semantics are unambiguous.

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

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

There is no guidance on when to use this tool versus list_mac_groups, delete_mac_group, or the sibling add_mac_speed_limit / add_mac_access_control tools. No prerequisites, ordering, or exclusion conditions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether this overrides an existing MAC limit, not the units or valid ranges for upload/download_kbps, not whether the rule is active immediately, and not the permission requirements for a mutation.

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

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

The phrase is short but that brevity comes from under-specification rather than efficiency; there is no front-loaded purpose or scope to front-load. A single noun phrase is not a useful structure for a six-parameter mutation 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 six-parameter write operation with zero annotations and zero schema descriptions, the description is completely inadequate — an agent cannot determine valid inputs, side effects, or relationships to the existing MAC speed limit rules.

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

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

Schema description coverage is 0% across 6 parameters, and the description adds no parameter meaning whatsoever — mac, upload_kbps, download_kbps, comment, enabled and time_range are all unexplained in both places.

Input schemas describe structure but not intent. Descriptions should explain 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 '添加 MAC 限速' is a direct restatement of the tool name and title ('Add Mac Speed Limit'), so it conveys no information beyond the identifier. It vaguely distinguishes MAC from the IP-based siblings, but does not say what a speed limit is applied to or how it takes effect.

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

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

No when-to-use guidance, no prerequisites, and no mention of the alternatives (add_ip_speed_limit, list_mac_speed_limits, delete_mac_speed_limit). The agent must infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: no mention of required permissions, whether the rule takes effect immediately, reversibility, or how defaults are applied. For a mutation tool this is a total gap.

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

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

The single short phrase is not padded, but it is under-specified rather than concise. Brevity here reflects missing content, not 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?

An 8-parameter mutation tool with no annotations, no parameter documentation, and only a name restatement is far from complete enough for an agent to call it correctly, even though an output schema exists.

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

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

Eight parameters exist with 0% schema description coverage, and the description explains none of them. Fields like src_addr, dst_port, protocol, and interface are left completely undocumented in both the schema and 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 phrase '添加端口分流规则' only restates the tool title 'Add Port Forwarding Rule' in another language; it conveys no more than the name already does. It does not distinguish this tool from siblings such as list_port_forwarding_rules or delete_port_forwarding_rule.

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

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

There is no indication of when to use this tool versus the sibling list/delete variants, nor any prerequisite or context. The description offers no usage guidance at all.

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

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

With no annotations provided, the description carries the full disclosure burden and delivers none of it. It does not state that this is a mutating operation, whether the mapping takes effect immediately, whether it can conflict with existing mappings, or what permissions are required.

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

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

It is short, but this is under-specification rather than conciseness; there is effectively no content to front-load. Brevity here penalizes rather than helps the agent.

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

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

An 8-parameter mutation tool with zero annotation coverage and zero schema descriptions needs substantial prose to be callable correctly; an output schema exists so return values need not be covered, but everything else is missing.

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

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

Schema description coverage is 0% across 8 parameters (name, comment, enabled, protocol, interface, internal_ip, internal_port, external_port), and the description documents none of them. Critical ambiguities — protocol values, port format, ip/port relationships — are left entirely unexplained.

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

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

"添加端口映射" translates directly to the tool name/title "Add Port Mapping", so it is essentially a tautological restatement rather than an independent statement of purpose. It conveys no scope, no target object details, and does not distinguish this from siblings such as add_port_forwarding_rule, list_port_mappings, or delete_port_mapping.

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

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

There is no guidance whatsoever on when to use this tool versus the many related port/forwarding/NAT tools in the sibling list. No prerequisites, no when-not-to-use, no alternatives are named.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure, and it discloses nothing. For a mutation tool it never states that it creates persistent state, what happens on duplicate usernames, or any auth/permission requirement.

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

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

It is short with no filler, but this is under-specification rather than conciseness — a five-character phrase cannot be considered well-structured for a six-parameter creation tool.

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

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

With no annotations, 0% parameter coverage, and a mutation that creates an account, the description omits everything an agent needs beyond the name. The existence of an output schema excuses it from explaining return values, but nothing else is covered.

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

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

Six parameters with 0% schema description coverage: username, password, comment, ip_type, upload_kbps, download_kbps. The description explains none of them, leaving the agent with no idea what ip_type values (e.g. 'auto') mean or what the kbps fields control.

Input schemas describe structure but not intent. Descriptions should explain 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 '添加 PPPoE 账号' is a direct Chinese restatement of the tool name and English title 'Add Pppoe Account', adding no information an agent doesn't already have from the identifier. It does convey verb+resource, but that is pure tautology rather than added clarity.

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

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

No guidance on when to add a PPPoE account versus using siblings such as add_vpn_account, add_admin_account, or checking list_pppoe_accounts first. No mention of prerequisites (e.g. that the PPPoE server must be enabled via toggle_pppoe_server) or how this differs from list_pppoe_accounts / delete_pppoe_account.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it discloses nothing: no required permissions, whether the route takes effect immediately, conflicts with existing routes, or reversibility. For a mutation tool this is a serious gap.

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

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

The text is short but this is under-specification rather than conciseness; a single translated phrase cannot front-load anything useful. Brevity here reflects missing content, not 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?

With no annotations, 6 undocumented parameters at 0% schema coverage, and only a name restatement, the definition gives an agent almost nothing needed to invoke the tool correctly. An output schema exists but does not compensate for missing input semantics.

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

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

Schema description coverage is 0% across 6 parameters (destination, netmask, gateway, metric, comment, interface), and the description mentions none of them. It provides no format hints (e.g., CIDR vs dotted netmask) or meaning for optional fields.

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

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

"添加静态路由" is a direct translation of the tool name add_static_route; it restates the resource and verb but adds no scope, differentiation from siblings, or specificity. It is essentially tautological rather than descriptive.

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

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

No guidance on when to use this tool versus alternatives such as list_static_routes, delete_static_route, or get_routing_table. No prerequisites, no context, no exclusions 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 behavioral burden, yet it discloses nothing about the mutation's effect, required permissions, whether entries take effect immediately, or what the mode/week/time_range fields mean. This is a write tool with essentially zero behavioral disclosure.

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

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

It is a single short phrase, but this is under-specification rather than useful conciseness. Nothing is front-loaded because nothing beyond the bare act is stated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 six-parameter mutation tool with no annotations and 0% schema coverage, the description is wholly inadequate; only the existence of an output schema relieves it of explaining return values, which does not offset the missing input semantics.

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

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

Schema description coverage is 0% across six parameters, and the description adds no meaning for url, mode, week, comment, enabled, or time_range. The critical mode parameter (apparently selecting blacklist vs whitelist) is completely unexplained, leaving the agent unable to set it correctly.

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

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

States a verb (add) and a resource (URL black/white list), so the basic operation is inferable. However, '黑白名单' ambiguously conflates blacklist and whitelist without clarifying which list is modified or how, and there is no differentiation from siblings like list_url_blacklist or delete_url_blacklist.

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

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

The description gives no when-to-use guidance, no prerequisites, and does not point to the companion tools (list_url_blacklist to inspect, delete_url_blacklist to remove). Usage must be entirely inferred from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not say whether vlan_id must be unique, whether the change is immediate or requires a commit, whether admin privileges are needed, or what happens on conflict.

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

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

Two words is short, but this is under-specification rather than conciseness - there is no front-loaded guidance to compress. There is simply nothing to structure.

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

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

A mutation tool with 5 undocumented parameters, no annotations, and a non-trivial required triple (vlan_id, name, interface) needs far more than a two-word label. The output schema covers return format, but all input and behavioral context is absent.

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

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

Schema description coverage is 0% across 5 parameters (vlan_id, name, interface, ip, comment), and the description adds no parameter meaning at all. The agent gets no format, range, or relationship information for any of 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 '添加 VLAN' merely restates the tool name and title in another language. It conveys the bare verb+resource (add a VLAN) but nothing about scope, target device, or how it differs from the many other add_* configuration tools in the sibling set.

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

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

No when-to-use guidance, no prerequisites, and no reference to the obvious alternatives (list_vlan_configs, delete_vlan, list_wireless_vlans). The agent must infer entirely from the name that this creates a VLAN rather than modifying or querying one.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the act of adding. It does not mention required permissions, side effects, prerequisite server configuration, or whether the new account takes effect immediately. Only the implicit 'add' mutation semantics are conveyed.

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

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

The single Chinese phrase is clean and front-loaded with no wasted words, but for a five-parameter mutation tool it is under-specified rather than genuinely concise. Brevity here reflects missing information rather than disciplined editing.

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

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

Given five parameters (three required), no annotations, and low schema coverage, the description is far too thin. An output schema exists so return values need not be explained, but the agent gains no understanding of prerequisites, parameter meaning, or behavioral expectations for this mutating 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 only 20% (only vpn_type is documented), so the description must compensate for username, password, comment, and ip_type — but it says nothing about any parameter. It adds no meaning over the sparse schema, leaving four parameters effectively undocumented in both places.

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

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

The description states an add operation on a VPN resource, but 'VPN account' versus 'VPN client configuration' (客户端配置) is ambiguous, and the term overlaps confusingly with 'VPN client' tools like list_vpn_clients and get_pptp_client_config. It does not distinguish itself from the delete_vpn_account/list_vpn_accounts siblings or clarify whether this targets a server-side account or an outbound dialing profile.

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

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

There is no guidance on when to use this tool, what prerequisites exist (e.g., an existing VPN server of the matching vpn_type), or how it relates to alternatives. The agent is left to infer context entirely from the name and sibling list.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses nothing: no mention of required permissions, whether the old password must match the caller's own credentials, whether the change is irreversible, or whether it invalidates active sessions or API tokens. For a credential-mutation tool 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 one-line description is short but under-specified rather than concise; it spends its only sentence repeating the title and leaves no room for the safety-relevant context this operation needs. Brevity here is a deficiency, not an 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?

An output schema exists so return values need no explanation, but for a security-sensitive admin credential change with zero annotations the description should at least state auth requirements and password constraints. None of that is present, leaving the definition materially incomplete.

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

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

Schema description coverage is 100%, so old_password, new_password, and confirm are already documented in the schema (including the note that confirm must be True). The description adds nothing beyond that, so the baseline of 3 for high schema coverage applies.

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

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

The description '修改管理员密码' is a Chinese restatement of the title 'Change Admin Password' and adds no distinguishing information. It names a verb and resource only in the tautological sense of repeating the tool name, and gives no hint of scope, target account, or how it differs from siblings like list_admin_accounts or add_admin_account.

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

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

There is no indication of when to use this tool versus alternatives such as add_admin_account or get_password_self_service, nor any prerequisite about which admin identity must be authenticated. The agent receives no routing guidance at all.

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

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

Annotations already declare readOnlyHint=true and the output schema covers the return shape, so the bar is lower. The description still adds real value by explicitly stating it does not trigger download or installation, which scopes the side effects beyond the generic read-only hint.

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

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

A single short sentence with the core action front-loaded and the safety scoping in a parenthetical. Nothing is padded and nothing extraneous is present.

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

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

For a zero-parameter read-only check with an output schema and readOnlyHint annotation, the description covers what the tool does and what it does not do. The only gap is that it does not position itself against the neighbouring firmware tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. No parameter meaning is claimed or needed.

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

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

States a specific verb and resource ('检查是否有新固件' = check for new firmware), which is clear on its own. However, it does not differentiate from closely-related siblings such as get_firmware_version, get_auto_upgrade_status, or start_firmware_upgrade, so an agent must infer the boundary itself.

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

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

The parenthetical '只读，不触发下载与安装' implies this is a safe pre-check rather than the upgrade action, hinting at when to use it instead of start_firmware_upgrade. But no alternative is named and no explicit condition or prerequisite is given, so usage remains inferred rather than stated.

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

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

No annotations are provided, so the description carries the full burden. 'Clean' implies deletion of files, but the description never states what is removed, whether the action is reversible, whether it affects the active firmware image, or what permissions are needed. For a destructive operation this is a significant gap.

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

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

A single short phrase that is front-loaded and free of waste. It is efficient, though the extreme brevity leaves it under-specified rather than genuinely concise.

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

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

An output schema exists so return values need not be explained, but for a deletion tool with zero annotation coverage the description should disclose destructiveness, scope, and safety prerequisites. It leaves an agent without enough context to invoke it safely.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents the confirm flag and its default. The description adds no meaning beyond the schema, making the baseline of 3 appropriate.

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

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

The description states a specific verb+resource ('clean downloaded firmware files'), so an agent can tell what the tool does. However, it offers no differentiation from the many firmware-related siblings such as get_firmware_version, check_firmware_update, and start_firmware_upgrade.

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

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

There is no guidance on when to use this tool, no prerequisites, and no mention of alternatives. The agent gets a purpose statement but nothing about the conditions that should trigger cleanup.

Agents often have multiple tools that could apply. Explicit usage 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' does signal a destructive mutation, but nothing is said about irreversibility, required permissions, or side effects on attached policies. This is far too thin for a destructive operation 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?

It is a single short phrase with no filler and the object is front-loaded, but the brevity here reflects under-specification rather than efficiency. There is nothing to trim and nothing to reward.

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

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

An output schema exists, so return values need not be explained, but the description still omits everything else an agent needs: which rule set 'rule_id' refers to, the destructive consequence, and how it differs from toggle_acl_rule. A destructive tool with one undocumented parameter needs substantially more text.

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

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

Schema description coverage is 0% and the single parameter 'rule_id' has no type description or constraints in the schema. The description does not mention the parameter at all, so it fails to compensate for the coverage gap.

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

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

The description ('删除 ACL 规则') is a literal translation of the tool name and title, adding no information beyond them. It does not distinguish this tool from siblings such as add_acl_rule or toggle_acl_rule. Per the rubric this is a tautology that restates the name/title.

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

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

No when-to-use guidance is given. It does not say when to delete an ACL rule, whether a list_acl_rules call should precede it to obtain the rule_id, or how it relates to toggle_acl_rule (disable vs. delete).

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

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

No annotations are provided, so the description carries the full behavioral burden for a destructive mutation. It says nothing about irreversibility, whether the rule can be recovered, required permissions, or side effects on traffic policy — all critical for a delete operation.

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

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

It is short, but this is under-specification rather than conciseness — a single phrase that restates the name without earning its place by adding any actionable information.

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

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

An output schema exists, so return values need not be explained. However, for a destructive tool with zero annotations, zero schema coverage, and no parameter guidance, the one-phrase description leaves the agent without enough context to invoke it safely or correctly.

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

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

Schema description coverage is 0% and the single rule_id parameter has no description in either the schema or the tool description. The description does not explain where to obtain a valid rule_id (e.g., from list_app_protocol_rules) or what happens with an invalid id.

Input schemas describe structure but not intent. Descriptions should explain 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 app protocol control) merely restates the tool name/title with no additional specification. It does not distinguish this tool from its close siblings list_app_protocol_rules, add_app_protocol_rule, or toggle_app_protocol_rule, which an agent must choose between.

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

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

No when-to-use context, no prerequisites, and no mention of the alternative toggle_app_protocol_rule, which is the obvious non-destructive sibling an agent might prefer. Nothing tells the agent under what circumstances deletion is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the deletion is permanent or reversible, whether the binding must exist, what error occurs for an unknown binding_id, or what permissions are required. For a destructive operation this is a serious gap.

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

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

Four characters with zero padding and the operation is front-loaded, so it is structurally clean. However, the terseness reflects under-specification rather than disciplined conciseness, keeping it at a middling score.

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

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

An output schema exists so return values need not be described, but for a destructive tool with no annotations and no parameter documentation the description is far too thin. An agent cannot confirm scope, side effects, or the id's origin from this text alone.

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

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

Schema description coverage is 0% and the single required parameter binding_id has no type semantics or format guidance in either the schema or the description. The phrase 'ARP binding' hints at what the id refers to, but no lookup source or expected form is given.

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

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

The description is a verbatim Chinese translation of the tool title ('Delete Arp Binding'), adding no information beyond the name. It is a tautology rather than a purpose statement, and offers nothing to distinguish it from list_arp_bindings or add_arp_binding beyond what the name already conveys.

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

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

There is no guidance on when to delete a binding versus other cleanup operations, no prerequisites, and no warning about consequences. At best the verb 'delete' weakly implies intent; nothing about when/when-not is stated.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the deletion is irreversible, whether it requires elevated permissions, what happens to existing connections governed by the rule, or whether it is idempotent. This is a destructive mutation with zero behavioral disclosure.

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

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

The description is a six-character phrase that merely restates the tool name and title. Brevity here reflects under-specification rather than efficient front-loading of useful information.

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

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

An output schema exists so return values need not be explained, but for a destructive tool with no annotations the description should at minimum cover prerequisites, irreversibility, and how to obtain the required rule_id. None of that is present.

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

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

Schema description coverage is 0% and the single parameter rule_id has no description in either the schema or the tool description. The description does not say where rule_id comes from (presumably list_connection_limits) or whether deletion fails for unknown IDs.

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

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

The description states a specific verb (删除/delete) and resource (连接数限制/connection limit), so the agent knows exactly what it targets. It does not explicitly differentiate itself from the sibling list_connection_limits or add_connection_limit, but the verb makes the intent unambiguous.

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

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

There is no guidance on when to call this versus list_connection_limits or add_connection_limit, nor any prerequisites such as needing a rule_id obtained from the list endpoint. The agent must infer all usage context from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing beyond the bare verb 'delete'. It does not state that deletion is irreversible, whether in-use rules referencing the library are affected, or what permissions are required.

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

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

The single phrase is short but under-specified rather than concise; it spends its only words duplicating the title instead of front-loading any useful information.

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

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

For a destructive operation with no annotations, an undocumented required parameter, and only an output schema to cover return values, the description is far too thin. An agent cannot call this correctly or safely on the basis of the text alone.

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

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

Schema description coverage is 0% and the description never mentions the single parameter. The agent gets no clarification of what group_id refers to (presumably a custom URL library identifier from list_custom_url_library) or how to obtain it.

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

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

The description '删除自定义网址库' is a verbatim Chinese restatement of the tool's own name/title ('Delete Custom Url Library'). It conveys the verb+resource but adds nothing an agent could not infer from the identifier, and it does not distinguish this tool from near neighbors such as delete_url_blacklist or delete_domain_blacklist.

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

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

No when-to-use, when-not-to-use, or alternative guidance is given. There is no mention of its relationship to list_custom_url_library or add_custom_url_library, nor any prerequisite such as needing a valid library id.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing: no statement of irreversibility, permission requirements, side effects on related DDNS state, or confirmation behavior. The only implicit signal is that deletion is destructive, which the agent gets from the verb alone.

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

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

While extremely short, this is under-specification rather than conciseness: a single phrase that adds nothing beyond the tool name. Brevity here is not earning its place because no useful information was included to begin with.

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

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

An output schema exists, so return values need not be explained, but for a destructive operation with no annotations and an undocumented required id parameter the definition is materially incomplete. The agent cannot tell preconditions, side effects, or error cases from this text.

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

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

Schema description coverage is 0% for the single parameter record_id, and the description adds no meaning about it (where the id comes from, expected format, or how to obtain it from get_ddns_config/list results). With a non-trivial required parameter fully undocumented, the description fails to compensate for the schema gap.

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

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

"删除 DDNS" names a clear verb (delete) and resource (DDNS) and is unambiguous against siblings like add_ddns, get_ddns_config and get_ddns_log. However, it is essentially a restatement of the tool name with no scope or differentiation detail (e.g. whether it removes a rule versus a cached registration), so it lands at minimum-viable clarity rather than a strong 4-5.

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

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

There is no guidance on when to call this versus add_ddns or get_ddns_config, no prerequisites (does the DDNS entry need to exist / be disabled first?), and no mention of what the caller must supply beyond the id. A mutation tool with zero usage context leaves the agent to infer everything.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it delivers nothing beyond the implied destructiveness of '删除'. It does not state whether the deletion is reversible, what permissions are required, or what happens to a lease when its binding is removed.

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

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

The single phrase is front-loaded and free of padding, so it is concise. However, that brevity stems from under-specification rather than efficient communication, so it earns only a middling score.

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

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

Although an output schema exists (so return values need not be described), a destructive mutation tool with zero annotation coverage, zero parameter documentation, and no usage guidance is under-specified for reliable invocation.

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

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

Schema description coverage is 0% and the single parameter (record_id) is completely undocumented in both schema and description. The description gives no hint about what identifier is expected (an internal binding record vs. an IP/MAC), leaving the agent to guess.

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

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

The description is a direct Chinese restatement of the tool name ('删除 DHCP 静态分配' vs. 'Delete Dhcp Static Binding'), adding no information beyond the title. It is not misleading, but it is a tautology rather than an informative statement of purpose, and it draws no distinction from siblings such as list_dhcp_static_bindings or add_dhcp_static_binding.

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

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

There is no indication of when to use this tool versus the closely related add/list DHCP static binding tools, nor any prerequisite or precondition. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not that this is a destructive/irreversible removal, not whether confirmation or elevated permissions are required, not what happens to traffic for the removed domain, and not that rule_id must come from an existing listing.

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

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

It is short, but this is under-specification rather than conciseness — one six-word phrase that duplicates the title and front-loads no actionable information.

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

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

The tool is simple and an output schema exists (so return values need not be explained), but for a destructive, zero-annotation operation the description omits the minimum an agent needs: what rule_id identifies, where to get it, and that the deletion is permanent.

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

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

Schema description coverage is 0% and the description never mentions rule_id, its type, its format, or where to obtain it. With a single required integer parameter and no schema text, the description should compensate and does not.

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

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

"删除禁止娱乐网站" restates the tool name rather than defining it: it does not say what a blacklist entry is keyed by, nor that it acts on a single rule. It does add a hint about the domain of the blacklist (banned entertainment sites), but an agent learns essentially nothing beyond the name.

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

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

No when-to-use, no when-not-to-use, and no pointer to the obvious companion tools list_domain_blacklist (to obtain rule_id) or add_domain_blacklist. The agent must infer the whole workflow from the sibling list.

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

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

No annotations are provided, so the description carries the full burden — and it discloses nothing. It does not state that the operation is destructive and irreversible, whether deleting a rule affects other forwarding/NAT behavior, what permissions are required, or what the response contains. The single word 'delete' merely duplicates the tool 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?

Six characters with no waste, but this is under-specification rather than conciseness — there is no front-loaded explanation of effect, prerequisites, or outcome. Being short is not the same as being well-structured when the content is absent.

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

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

An output schema exists, so return values need not be explained. Everything else is missing, though: for a destructive one-parameter tool with zero annotations, the description never says how to obtain a valid rule_id, whether deletion is reversible, or what side effects occur on the device.

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

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

Schema description coverage is 0% and the description says nothing about rule_id — not its format, not where to source it, not whether it must reference an existing rule. The only mitigating factor is that there is a single, self-evident integer identifier, so the gap is smaller than it would be with multiple opaque parameters.

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

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

The description names a specific verb and resource (delete + domain forwarding rule), which is enough to separate it from the add_/list_ domain-forwarding siblings. However, it adds nothing beyond the tool name and title — it is essentially the same string translated, with no scope, conditions, or differentiator of its own.

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

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

No when-to-use, no prerequisites, and no mention that the rule_id must first be obtained from list_domain_forwarding_rules. An agent gets no routing help at all; the only reason this isn't a 1 is that the text is not actively misleading.

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

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

With no annotations, the description carries the full burden for a destructive mutation, yet it says nothing about irreversibility, whether groups referenced by ACL/routing rules can be deleted, or what happens to dependent references. Only the implicit 'delete' verb signals mutation.

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

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

A single six-character sentence with no padding and the action front-loaded, so nothing is wasted. However, it is under-specified rather than concise — the brevity comes at the cost of any useful 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?

An output schema exists so return values need not be explained, but for a no-annotation destructive tool with 0% parameter coverage the description leaves critical gaps: preconditions, side effects on referencing rules, and how to identify the target group.

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

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

Schema description coverage is 0% and the description adds no parameter meaning at all. Neither group_id (how to obtain it, integer ID semantics) nor ip_type (the v4 default and what other values exist) is clarified anywhere.

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

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

Clear verb+resource pair ('删除 IP 地址分组') that names exactly what is removed, and it is distinguishable from list_ip_groups/add_ip_group. It offers no differentiation against adjacent siblings like delete_mac_group or an explicit note on which group namespace is affected.

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

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

No when-to-use guidance, no prerequisites, no warning that this is a destructive call, and no pointer to list_ip_groups for discovering valid group_id values. The agent must infer all of this from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure and fails to meet it. It says nothing about irreversibility, required permissions, behavior when the rule_id does not exist, or any other consequence of this 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?

A single three-word phrase is not conciseness but under-specification; there is no waste, but almost no content either, and nothing is front-loaded because nothing else exists.

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

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

For a destructive delete tool with no annotations, no parameter documentation, and no usage guidance, the definition is materially incomplete. An output schema exists so return values need not be explained, but that alone does not compensate for the missing identifier sourcing and safety context.

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

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

Schema description coverage is 0%, and the description does not mention rule_id at all. With only one required integer parameter it is partly self-explanatory by name, but the agent gets no hint that the ID comes from list_ip_speed_limits or what format it takes.

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

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

"删除 IP 限速" states a specific verb (delete) and resource (IP speed limit), so the operation is identifiable. However, it is essentially the title restated in another language and adds no differentiation from siblings such as add_ip_speed_limit or delete_mac_speed_limit beyond what the name already conveys.

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

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

There is no when-to-use guidance, no prerequisite, and no mention of alternatives such as list_ip_speed_limits for obtaining a rule ID. The agent must infer all usage context 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 the full burden of behavioral disclosure, and it says nothing about irreversibility, required permissions, or side effects. The only behavioral hint is the verb "delete," which conveys mutation but not the consequences of the call.

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

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

The description is a single short phrase with no wasted words and is trivially front-loaded. However, the brevity reflects under-specification rather than effective conciseness.

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

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

An output schema exists, so return values need not be described, but for a destructive mutation tool with zero annotations and an undocumented identifier parameter, the description is far too thin. It omits everything an agent needs beyond the tool name to invoke this 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 0% and the single parameter rule_id is undocumented in both the schema and the description. The description gives no indication of what a rule_id is, its format, or where the caller should obtain one (e.g., from list_mac_access_control).

Input schemas describe structure but not intent. Descriptions should explain 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 "删除 MAC 访问控制" is a word-for-word restatement of the title "Delete Mac Access Control" in Chinese, adding no information beyond the name. It neither clarifies what a MAC access control rule is nor distinguishes this tool from siblings such as list_mac_access_control or add_mac_access_control.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives or related tools. An agent must infer entirely from the tool name that this removes an existing rule created by add_mac_access_control.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Delete' implies a destructive, likely irreversible mutation, but the description says nothing about consequences, whether groups in use by policy rules can be removed, required permissions, or error 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?

It is a single front-loaded phrase with no filler, which is structurally clean. But the extreme brevity reflects under-specification rather than effective conciseness for a destructive 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?

An output schema exists so return values need not be described, but for a destructive tool with no annotations, no parameter documentation, and no usage guidance, the definition is far too thin to call correctly with confidence.

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

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

Schema description coverage is 0% and the single parameter group_id is undocumented in both schema and description. The description does not state what the identifier refers to or how to obtain it (e.g. from list_mac_groups), leaving the one required parameter unexplained.

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

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

States a specific verb and resource ('删除' + 'MAC 地址分组'), so an agent knows this removes a MAC address group. However it offers no differentiation from closely related siblings such as delete_ip_group or delete_mac_access_control, which share the same delete-X-group pattern.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g. group must exist or be unused), and no exclusions. The agent must infer all usage context from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Delete' implies a destructive mutation, but the description says nothing about reversibility, required permissions, or side effects on existing traffic limits.

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

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

The phrase is extremely short and front-loaded, but this is under-specification rather than conciseness. Nothing about the operation's scope or the required identifier earns its place because nothing is stated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 a fully undocumented required parameter, the description is inadequate despite an output schema existing. An agent cannot confidently call this tool without guessing what rule_id should be.

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

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

Schema description coverage is 0% and the single parameter rule_id is undocumented in both the schema and the description. The description adds no meaning about what rule_id refers to or how to obtain it.

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

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

The description states a specific verb+resource ('删除 MAC 限速' = delete MAC speed limit) and clearly distinguishes it from siblings like delete_ip_speed_limit and list_mac_speed_limits. It is clear but adds no scope detail beyond the name/title.

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

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

There is no indication of when to use this tool versus alternatives, no prerequisites, and no mention of what happens to traffic when a limit is removed. The agent must infer everything from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not state that the operation is irreversible, whether a confirmation is required, whether dependent resources are removed, or what the response contains — critical omissions for a destructive delete 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 extremely short, but this reflects under-specification rather than disciplined conciseness. There is nothing to front-load because the entire description is a copy of the title.

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

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

Although an output schema exists (so return values need not be described), this destructive tool has no annotations, no parameter documentation, and no usage context. For a delete operation with a required identifier, the description is wholly inadequate.

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

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

Schema description coverage is 0% and the single parameter rule_id has no schema description, so the description must compensate — and it does not. It never mentions the rule_id parameter, its expected format, or where the identifier can be obtained.

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

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

The description is a verbatim translation of the tool name ('delete port diversion'/'delete port forwarding rule'), so it adds no information beyond what the tool name already conveys. While the verb+resource pairing ('delete' + 'port forwarding') is technically interpretable, it is a tautological restatement rather than a distinguishing statement against siblings like delete_domain_forwarding_rule.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no warning about the destructive operation. The agent receives nothing about obtaining a valid rule_id beforehand (e.g., via list_port_forwarding_rules) or how deletion interacts with add_port_forwarding_rule.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the word 'delete'. It does not state that the operation is destructive and irreversible, whether confirmation or elevated permissions are required, or how failures (e.g., unknown rule_id) are handled.

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

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

It is a single short phrase, so it is not verbose, but this is under-specification rather than conciseness: every sentence that could earn its place is absent.

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

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

Although an output schema exists (so return values need not be explained), the description leaves the core calling information missing: no parameter meaning, no destructive-operation context, and no routing to the listing tool that supplies rule_id. Inadequate for a mutation tool with zero annotation 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 0% and the single parameter rule_id has no description anywhere, so the description must compensate — but it adds no meaning whatsoever about what rule_id is, how to obtain it (e.g., via list_port_mappings), or its format.

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

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

The description states a specific verb and resource ('删除端口映射' / delete port mapping), which tells the agent exactly what it does. However, it merely restates the tool name and title without any scope, and gives no differentiation from the adjacent list_port_mappings / add_port_mapping / delete_port_forwarding_rule siblings.

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

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

There is no guidance on when to use this tool versus alternatives such as delete_port_forwarding_rule or the list/add counterparts, no preconditions, and no note about needing the rule to exist first. Usage is only implied by the obviousness of the verb.

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

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

No annotations are provided, so the description carries the full disclosure burden. 'Delete' implies a destructive mutation, but nothing is said about permanence, reversibility, whether the account must be offline first, permission requirements, or cascading effects (e.g., deleting associated credentials/sessions).

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

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

The description is a single short phrase with no filler, so it is concise, but it is sized far below what a destructive, undocumented parameter tool warrants. It is front-loaded in the trivial sense that there is only one clause.

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

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

With no annotations, 0% parameter coverage, and an output schema present (so return values need not be explained), the description is still missing key behavioral context for a destructive delete operation. An agent lacks the information needed to invoke it safely and correctly.

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

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

Schema description coverage is 0% and the description provides no information about the single parameter user_id — not its format, source (e.g., from list_pppoe_accounts), or whether it accepts a username vs. an ID. It adds nothing beyond the schema's bare integer type.

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

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

The description states a specific verb+resource ('删除 PPPoE 账号' = delete PPPoE account), which is clear enough to tell apart from siblings like list_pppoe_accounts, add_pppoe_account, and kick_pppoe_user. However, it is essentially a verbatim restatement of the tool name/title and adds no scope, target, or distinguishing detail beyond that.

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

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

There is no guidance on when to use this tool versus alternatives such as kick_pppoe_user (disconnect vs. delete) or delete_vpn_account. The agent must infer usage entirely from the tool name, with no conditions, prerequisites, or exclusions 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 behavioral burden, and it discloses nothing: not that deletion is destructive/irreversible, not permission or dependency requirements (does deleting a route affect traffic?), not whether it needs confirmation. A bare 'delete' phrase on a mutation tool 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 text is short but under-specified rather than concise; it is essentially a translated tool name and contains no front-loaded context that would help an agent act. Length is not the problem — absence of content is.

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

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

The tool is simple (one required integer) and an output schema exists, so return values need not be explained. Still, with zero annotations and no parameter documentation, an agent cannot tell how to source the route_id or what the side effects of deletion are; more description was warranted.

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

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

The single required parameter route_id has 0% schema description coverage, and the description adds nothing about it — no format, no indication of how to obtain a valid ID (e.g. from list_static_routes). The one parameter that determines whether the call succeeds is entirely undocumented.

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

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

The phrase '删除静态路由' (delete static route) states a clear verb+resource, so the agent knows the operation. However it offers no differentiation from adjacent siblings such as delete_vlan, delete_dhcp_static_binding, or the companion list_static_routes/add_static_route, so it barely clears the minimum-viable bar.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives (e.g. list_static_routes to find the ID, or how it differs from delete_vlan). Usage is only implied by the verb.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: not that deletion is destructive and irreversible, not whether it requires elevated permissions, not what happens if the rule_id does not exist, and not how many entries are affected.

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

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

A single six-word phrase is not wasteful, but it is under-specification rather than conciseness: it omits everything an agent would need. Brevity here costs correctness rather than improving signal.

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

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

For a destructive, unannotated, one-parameter mutation with 0% schema coverage, the description is far too thin. The presence of an output schema excuses it from describing return values, but nothing else about the operation is covered.

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

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

Schema description coverage is 0% and the single required parameter rule_id is undocumented in both schema and description. The description should at minimum explain that rule_id identifies an existing blacklist entry and where to obtain it, but gives no parameter meaning at all.

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

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

"删除网址黑白名单" restates the tool name almost verbatim (delete + URL blacklist), adding no distinguishing detail. It also drifts from the name by saying 黑白名单 (black/white list) while the tool and siblings (list_url_blacklist, add_url_blacklist) are scoped to a blacklist, so the agent cannot cleanly tell what resource is being deleted.

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

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

There is no when-to-use guidance, no prerequisite (e.g. that a rule_id must first come from list_url_blacklist), and no mention of the neighboring add_url_blacklist / list_domain_blacklist / delete_domain_blacklist tools. The agent must infer the entire usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the name. It does not state that the operation is irreversible, whether active traffic on the VLAN is disrupted, what happens if the VLAN is referenced by other config, or any permission requirements.

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

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

The description is extremely short, but this reflects under-specification rather than disciplined conciseness. There is no waste, but also essentially no content, so brevity earns no credit here.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, a required undocumented parameter, and configuration-modifying impact, the description is completely inadequate. An output schema exists so return values need not be explained, but every other aspect of correct invocation is missing.

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

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

Schema description coverage is 0% for the single parameter vlan_id, and the description adds no clarification of its format, source, or valid range. Only the resource noun "VLAN" loosely implies what vlan_id refers to, which is marginal compensation for the coverage gap.

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

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

"删除 VLAN" (Delete VLAN) merely restates the tool name and title "Delete Vlan" with no added specificity. It provides no scope information (which VLAN, whether wireless or wired) and does nothing to distinguish it from the many other delete_* siblings such as delete_ip_speed_limit or delete_dhcp_static_binding.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives like list_vlan_configs (to find the VLAN) or list_wireless_vlans. The agent is left to infer everything about invocation context.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it only delivers the bare "delete" verb. It does not disclose the destructive/irreversible nature, permission requirements, whether the delete cascades (sessions, configs), or any confirmation step. The verb implies mutation, but nothing beyond that is conveyed.

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

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

A single short sentence is not concise here—it is under-specified. Brevity is achieved by omitting required information rather than by front-loading it, and the one sentence still leaves the target object ambiguous.

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

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

This is a destructive two-required-parameter tool with zero annotations, zero schema descriptions, and no usage guidance. An output schema exists, so return values need not be explained, but everything else an agent needs to call this safely and correctly is missing.

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

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

Schema description coverage is 0% and both required parameters (user_id, vpn_type) are undocumented in the schema. The description mentions neither parameter, so it fails to compensate for the coverage gap; vpn_type accepts an unconstrained string with no enum or examples anywhere.

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

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

"删除 VPN 客户端配置" states a verb (删除) and a resource (VPN 客户端配置), which is minimally viable. However, the tool name says "account" while the description says "client configuration", and the sibling set contains both list_vpn_accounts/add_vpn_account and list_vpn_clients, so the agent cannot tell which object is actually removed. No differentiation from siblings is offered.

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

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

There is no guidance on when to use this tool versus list_vpn_accounts, add_vpn_account, or the other delete_* siblings. No prerequisites, no confirmation semantics, and no mention of what a caller must know before invoking it.

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

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

No annotations are provided, so the description carries the full behavioral burden. It omits whether the change takes effect immediately, whether enabling FTP requires a restart or exposes a security risk, and what happens to existing sessions. For a network-service mutation with zero annotation coverage this is a notable gap.

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

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

A single short phrase that is front-loaded and wastes no words. It is efficient, though its brevity contributes to the missing behavioral and usage 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?

Complexity is low (2 params, one required, output schema present so return values need no explanation) and the schema is fully documented. However, the absence of annotations means the description should have covered the effect and safety of toggling a network service, which it does not.

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

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

Schema description coverage is 100%, so both 'port' (default 21) and 'enabled' are fully documented in the schema. The description adds no semantics beyond what the schema already conveys, so the baseline of 3 applies.

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

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

States a specific resource (FTP service) and the action pair (enable/disable), which is clearer than the name 'enable_ftp' alone and disambiguates it from list/get siblings. It does not explicitly contrast itself with the near-identical toggle siblings (enable_ssh, enable_telnet), but the resource name makes separation obvious.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no mention of alternatives such as the sibling enable_ssh/enable_telnet toggles. The agent must infer all call conditions from the parameter name.

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

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

No annotations are provided, so the description carries the full disclosure burden and mostly fails it: nothing is said about permission requirements, whether the change persists across reboots, or the security impact of exposing SSH. It does earn minor credit for clarifying that the tool both enables and disables (despite the name `enable_ssh` implying one direction only), which matches the `enabled` flag.

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

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

A single short sentence with no padding and the action front-loaded. It is efficient but so terse that it reads as a label rather than a definition; slightly more substance could fit without bloat.

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

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

An output schema exists, so return values need not be explained, but for a security-relevant service toggle with zero annotations the description should say more about effects and prerequisites. The agent knows what the tool toggles but not when or under what constraints to call it.

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

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

Schema description coverage is 100%, with both `enabled` and `port` documented inline (including the port default of 22), so the schema does the heavy lifting. The description adds no meaning beyond the schema, which is the baseline-3 case.

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

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

The description names a specific resource (SSH service) and the exact action pair (enable/disable), which the agent can map directly onto the `enabled` boolean. It is clear in isolation, but it does nothing to distinguish this tool from closely-related siblings such as enable_telnet and enable_ftp.

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

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

There is no when-to-use guidance, no prerequisites (e.g. required admin privileges, whether SSH must be off/on before related operations), and no mention of alternatives or when-not-to-use. The agent gets no routing signal other than the obvious name match.

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

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

No annotations are provided, so the description carries the full burden. It does usefully disclose that this is a bidirectional toggle rather than an enable-only action, but it says nothing about permission requirements, whether the change is immediate or persisted across reboot, or any security risk of enabling Telnet — all material for a mutation tool.

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

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

A single short phrase with no filler and the resource is front-loaded. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be explained. But for a state-changing, security-sensitive toggle with zero annotations, the description should at least note permission requirements or persistence behavior, and it omits both.

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

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

Schema description coverage is 100% and the single boolean parameter is fully documented in the schema ('True=开启, False=关闭'). The description adds no extra semantics beyond that, so the baseline 3 applies.

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

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

The description states a specific verb+resource pair (enable/disable the Telnet service), which is clearer than the name alone, since the name only implies enabling. However, it offers no differentiation from near-identical siblings such as enable_ssh, enable_ftp, or toggle_wifi, which follow the same pattern.

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

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

There is no guidance on when to turn Telnet on or off, no mention of security implications (Telnet is cleartext), no prerequisites, and no routing to alternatives like enable_ssh. The agent must infer everything from the name.

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

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

readOnlyHint=true already tells the agent this is a safe, non-mutating read, so the description is not the sole carrier of the safety profile. It adds only that the payload centres on AP counts and online counts, which is largely duplicative of the existing output schema, so it clears the lower bar without contributing much behavioural 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?

A single short phrase with the resource first and the returned content in parentheses; no filler, no restatement of the title beyond what is needed. Well front-loaded.

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

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

For a zero-parameter read tool with an output schema and a readOnlyHint, the description covers what is needed to invoke it correctly; return-value detail is legitimately delegated to the output schema. The only gap is the absence of any routing context relative to sibling status tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. No parameter-related information is missing.

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