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

With no annotations, the description carries the full burden, and it does disclose two meaningful behaviors: a confirm flag is required to actually add the rule, and force bypasses a 'Network Guard' safety check. However, it never explains what Network Guard is, whether the rule takes effect immediately, or whether it conflicts with existing rules — significant gaps for a mutation tool with zero annotation coverage.

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

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

The purpose sentence is front-loaded and the parameter block is a tight one-line-per-parameter list with no filler. Slightly verbose in docstring style, but every line carries information the schema does not.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 documentation is thorough. What is missing for a write operation on a router is the surrounding context: persistence across reboot, interaction with existing rules, and the meaning of the Network Guard bypass.

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

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

Schema coverage is 0%, and the description fully compensates: all seven parameters are documented with meaning and concrete examples, plus semantics the schema lacks — internal_port defaults to external_port, protocol is constrained to TCP/UDP/ALL, and force bypasses Network Guard. The only small gap is that confirm is described circularly ('confirmation flag to add rule').

Input schemas describe structure but not intent. Descriptions should explain 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 first sentence states a specific verb and resource: creates a new NAT virtual server port forwarding rule on the router. The verb distinguishes it from the get_/del_ siblings, but the description never names those siblings or clarifies the boundary with router_set_dmz / router_set_upnp, which are also ways to expose internal services.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites such as admin auth, and no routing to alternatives like DMZ or UPnP for the same goal. The only usage-adjacent content is the confirm and force flags, which are invocation mechanics rather than guidance on when this tool is the right choice.

Agents often have multiple tools that could apply. Explicit usage 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 zero annotations the description carries the full burden and does well: it discloses that the modem detaches for 5-15 seconds per band switch, that a local daemon auto-reverts if WAN drops >45s, and that dry_run simulates without detachment — exactly the risk context an agent needs. Residual gaps are the calibration duration and whether the resulting band persists after the run.

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

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

Front-loaded with purpose and the single most important risk fact (45s watchdog fail-safe) in the first sentence, then the detach window. The Args block is somewhat redundant formatting-wise but earns its place given the empty schema descriptions.

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

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

For a disruptive multi-band calibration tool with no annotations and an output schema present, the description supplies the risk model, the fail-safe behavior, the dashboard side effect, and all parameter meanings. Nothing essential to calling it safely 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 coverage is 0%, so the Args block is the only documentation and it covers all four parameters meaningfully (web = launch UI, port = dashboard port, dry_run = simulate without modem detachment, confirm = execute). It does not state the effect of confirm=false (abort vs no-op) or any port constraints, leaving a small ambiguity.

Input schemas describe structure but not intent. Descriptions should explain 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: runs autonomous RF band calibration across named LTE bands (8, 3, 1, 40, Auto). The 'autonomous ... across frequencies' framing implicitly separates it from router_set_lte_band (single-band set), but it never names that sibling explicitly.

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

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

Usage is only implied: the Args line 'confirm: Confirmation flag to execute calibration' hints that confirm=true is required to actually run, and dry_run implies a safe trial path. There is no explicit when-to-use / when-not-to-use guidance and no routing to router_set_lte_band or router_set_cell_lock as alternatives.

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

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

With no annotations at all, the description carries the full burden, and it does disclose that the lookup is online and that a 'Network Guard safety check' can be bypassed via force — real behavioral detail. However, it never states that this is a read-only check that will not flash firmware, nor what happens when the check fails or the router is offline, which matters for a foreign-network 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?

Two short blocks, purpose first, parameter note second, with no filler. The Args stanza is slightly boilerplate but still earns its place since force is undocumented in the schema.

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

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

An output schema exists so return values need not be explained, and the single optional param is covered. But for a tool with zero annotations, a network-touching operation with a safety-bypass flag, the description should say whether it mutates anything and what the safety check protects — that gap is material.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'force' parameter, and it does explain the parameter's effect: it bypasses the Network Guard safety check. That said, 'Network Guard' is left undefined — the agent cannot tell what hazard is being bypassed or when bypassing is appropriate.

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

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

States a concrete verb and resource: checks for available online official TP-Link firmware updates. That is unambiguous and no sibling tool overlaps with firmware lookup, though the description never explicitly says it does not download or install, which is the obvious adjacent capability an agent might assume.

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

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

There is no statement of when to call this (e.g., before rebooting, during diagnostics) and no comparison against alternatives such as router_run_diagnostic or router_get_status. The only guidance-like content is the 'force' arg note, which is about a safety bypass rather than tool selection.

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

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

With no annotations, the description carries the full burden. It usefully discloses the confirm safety gate and that force bypasses a 'Network Guard safety check,' which is real behavioral context. It omits the critical point that clearing logs is irreversible and does not say what the response contains or whether confirmation is required despite required_parameters being 0.

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

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

The definition is short and front-loaded, with the core action in the first sentence and parameter meanings in a compact Args block. The parameter lines restate names but earn their place because the schema has no descriptions.

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

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

For a two-boolean destructive operation, the definition covers the safety flags but omits irreversibility and prerequisites. An output schema exists, so return values need not be explained, but the destructive nature of the operation should be explicit.

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

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

Schema description coverage is 0%, so the description must compensate — and it does, explaining confirm as a safety confirmation to clear logs and force as a bypass for the Network Guard safety check. It does not clarify how the two flags interact, such as whether force alone clears logs without confirm.

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

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

The description gives a specific verb and resource: 'Clears the internal system event log buffer on the router.' That is unambiguous. However, it never mentions the sibling router_get_system_logs, so the agent gets no explicit differentiation between reading and clearing logs.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 purpose implies when the tool is used, and the Args section explains that confirm must be True to proceed. But there is no explicit guidance on when to prefer router_get_system_logs instead, no note that this is destructive, and no indication of what happens if force is used without confirm.

Agents often have multiple tools that could apply. Explicit usage 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 zero annotations, the description carries the full burden. It discloses one genuinely useful trait — the existence of a Network Guard safety check that 'force' bypasses — but never states that deletion is irreversible, whether 'confirm' must be true for the delete to proceed, or what happens when the guard blocks 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?

Purpose is front-loaded in one clear sentence and the Args list is compact. The Args entries echo schema titles somewhat, but that repetition earns its place given 0% schema description coverage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, unannotated tool, the description omits irreversibility and recovery guidance, and never says how to obtain a valid rule_stack — meaningful gaps for this operation.

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

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

Schema description coverage is 0%, so the description must compensate and does so partially: all three params get a gloss and rule_stack gets a concrete format example ('2,1,1,1,0,0'). However, the interaction between confirm (default false) and the actual deletion is not explained, leaving the most safety-critical semantic ambiguous.

Input schemas describe structure but not intent. Descriptions should explain 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: deletes an existing NAT virtual server port forwarding rule, scoped by stack ID. The action is unambiguous and naturally distinct from router_add_port_forwarding and router_get_port_forwarding, though it never names those siblings explicitly.

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

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

No guidance on when to use this versus the get/add siblings, and no prerequisites such as where the rule_stack value should come from (presumably router_get_port_forwarding). The only guidance is the 'force' flag description, which is behavioral rather than selection-oriented.

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

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

With no annotations, the description carries the burden itself; it does disclose scope ('currently on the router LAN', wired and wireless) and the kind of data returned. However, it says nothing about whether results are cached, whether the call is read-only, or how long it takes to enumerate clients.

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

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

Two short sentences with the purpose front-loaded and no filler. The second sentence partly duplicates what the output schema already declares, which is the only waste.

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

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

An output schema exists, so explaining return fields is unnecessary, and the description is adequate on what the tool yields. But for a tool with an undocumented `force` flag and no annotations, an agent still lacks the context needed to decide when to set 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 0% and the description never mentions the single `force` parameter. Its semantics (presumably bypassing a cached client list) are left entirely ambiguous, so the description fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Retrieves all connected wired and wireless devices currently on the router LAN'), which clearly separates it from siblings like router_get_wifi_networks (configured networks) or router_get_status. It never explicitly names an alternative, so it stops short of a 5.

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

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

There is no guidance on when to call this versus related tools such as router_get_status, router_get_wifi_networks, or router_manage_dhcp_reservation. 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 burden. It does disclose the returned data points and implies a live/network-backed read ('live bandwidth'), but it says nothing about caching, latency, or why a force flag exists — meaningful gaps for a tool that may hit the modem.

Agents need to know what a tool does to the 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 tightly-packed sentence with the payload items front-loaded and no filler. Every word earns its place.

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

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

An output schema exists, so return values needn't be explained, and the description adequately foretells the payload. However, with no annotations and zero parameter documentation, an agent still lacks the information needed to decide whether to pass force.

Complex tools with many parameters or behaviors need more documentation. 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 'force' parameter is never mentioned in the description. The word 'live' might hint at freshness semantics, but it does not explain what force=true overrides, so the description 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?

Uses a specific verb ('Retrieves') plus three named data points (monthly cellular data allowance, billing cycle start day, live bandwidth), which lets an agent tell this read tool apart from router_set_data_limit without opening a schema. It does not explicitly name that sibling, so it falls short of a 5.

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

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

Usage is only implied: it's clearly the read counterpart to router_set_data_limit in the sibling list, but the description never states when to reach for this tool versus alternatives. There are no exclusions, prerequisites, or named alternatives.

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

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

No annotations exist, so the description carries the full load; it does disclose that a Network Guard safety check exists and that force bypasses it, which is genuinely useful behavioral context. However, it does not explain why the guard exists, what it protects against, or what happens (error vs empty result) when the guard blocks 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?

One front-loaded sentence stating purpose, plus a single line of parameter guidance. No filler or repetition of the tool name.

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

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

A read-only getter with an output schema, so return values need not be described, and the one optional parameter is explained. The remaining gap is the absence of any note on guard-blocked behavior or side effects of force, which an agent would need before setting it.

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

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

Schema coverage is 0% and the single parameter has no schema description, but the description compensates by explaining that force bypasses the Network Guard safety check and that it defaults to false. This is close to complete for a one-parameter tool, though it omits the consequence of enabling force.

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

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

The description gives a specific verb (Retrieves) and resource (DDNS provider configurations) and enumerates concrete providers (TP-Link Cloud, No-IP, DynDNS), making the scope unambiguous. It does not explicitly contrast with siblings such as router_set_dns, so it stops short of a 5.

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

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

The description never states when to call this versus alternatives, nor any prerequisites or exclusions. The only conditional guidance is the force flag's effect, which is a parameter note rather than usage routing.

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

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

With no annotations, the description carries the full burden. It does disclose that force bypasses a Network Guard safety check, which is useful behavioral context, but it does not explain the risk or implications of that bypass or state permissions/rate 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 description is short and front-loaded: the first sentence states the purpose, and the second explains the only parameter. There is no redundant or filler text.

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

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

For a simple read tool with an output schema, the core purpose and the force parameter are covered. However, without annotations it should say more about the safety-check bypass behavior and usage context to be fully complete.

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

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

Schema coverage is 0%, and there is one parameter. The description explains what force does, which adds meaning beyond the schema's bare boolean field. It still omits the default value and when force is appropriate, but it substantially compensates for the undocumented schema.

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

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

The description gives a specific verb and resource: retrieves DMZ host forwarding status and destination IP. It is clearly a read operation and is distinguishable from router_set_dmz by the verb, but it does not explicitly mention alternatives such as router_get_port_forwarding or router_get_upnp.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 states what the tool does but gives no guidance on when to use it versus alternatives. It does not mention prerequisites, when-not-to-use, or the conditions under which the force parameter should be set.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose that this is a retrieval operation and importantly notes that force=True bypasses a Network Guard safety check, but it does not explain what Network Guard protects, what risks the bypass entails, or any permission/auth requirements.

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

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

The description is short and front-loaded: the primary purpose appears first, followed by the only parameter's meaning. There is no redundant or wasted text.

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

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

For a one-parameter read tool with an output schema, the description supplies the essential purpose and the non-obvious force parameter semantics. It does not explain return values, which is acceptable because an output schema exists, but it could be more complete by clarifying when force is appropriate.

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

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

The schema has 0% description coverage and only defines force as a boolean with default false. The description compensates by explaining that force=True bypasses the Network Guard safety check, which is meaningful semantic information beyond the schema. The remaining gap is that it does not say when an agent should actually set force to true.

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

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

The description uses a specific verb, 'Retrieves,' and a specific resource, 'Guest Wi-Fi,' with useful scope details: dual-band status, SSIDs, and isolation settings. This clearly distinguishes it from the mutation sibling router_set_guest_wifi and is more specific than a generic Wi-Fi query.

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

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

Usage is implied by the tool name and the phrase 'Retrieves current ... Guest Wi-Fi status,' so an agent can infer this is the read-side counterpart to router_set_guest_wifi. However, the description does not explicitly name alternatives or state when to prefer this tool over router_get_wifi_networks, and it gives no guidance on when the force option is warranted beyond the safety-bypass note.

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

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

No annotations are provided, so the description carries the burden. It implies a safe read and scopes the return to LED status plus night mode schedule, but it never states that it is non-mutating, what 'force' changes behaviorally, or whether cached vs live state is returned. Return format is covered by the output schema.

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

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

One front-loaded sentence with no waste, naming both the primary result and the secondary schedule data immediately.

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

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

The output schema covers return values and there is no complexity from required params, but the undocumented 'force' flag and absence of any behavioral framing leave a real gap for an agent deciding whether to pass 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?

The single parameter 'force' has 0% schema description coverage and the description never mentions it, leaving its meaning and effect entirely unexplained. With coverage this low the description should compensate but 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?

States a specific verb (retrieves) and specific resources (physical LED status, night mode schedule), so an agent can distinguish it from router_set_led_night_mode. It does not explicitly name the sibling it complements, but the read framing is unambiguous.

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

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

There is no statement of when to use this versus alternatives such as router_set_led_night_mode or router_get_status. The read intent is implied by 'retrieves' but nothing is stated about context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only retrieval and usefully discloses the existence of a 'Network Guard safety check' that can block the call, but never explains what that guard is, why a read would be blocked, or what happens on failure.

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

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

Front-loaded one-line purpose followed by a compact args note; every sentence carries information. The raw docstring 'Args:' formatting is slightly unpolished but not wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 described, and the one parameter is meaningfully explained. For a simple single-value getter this is close to sufficient, with only the Network Guard mechanism left ambiguous.

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

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

Schema coverage is 0%, so the description must explain the single parameter, and it does: force bypasses the Network Guard safety check. It adds real meaning beyond the bare boolean type, though it leaves the guard's trigger conditions 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?

Specific verb (Retrieves) plus resource (active router operation mode) with the possible values enumerated (3G/4G Router Mode vs Wireless Router Mode). It doesn't differentiate itself from the nearest read-only sibling, router_get_status, which also reports router state.

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

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

There is no statement of when to call this versus alternatives, nor any prerequisite or exclusion. An agent must infer from the name that this is the mode-specific reader rather than the general status reader.

Agents often have multiple tools that could apply. Explicit usage 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 implicitly declares a read-only operation via "Lists" and mentions the cellular WAN scope plus a "Network Guard safety check," which is genuinely useful context, but it never explains what Network Guard is, what the check protects against, or what happens on failure.

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

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

Two short lines with the core purpose front-loaded and the parameter note separated. Nothing wasteful, though the inline "Args:" block is slightly informal for prose documentation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, with zero annotations covering a tool that exposes a safety-bypass flag, the description should say more about the consequences of force=True and how this differs from the add/del/port-forwarding siblings.

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

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

Schema coverage is 0% and the single parameter is documented only as a bare boolean named "force." The description supplies the meaning of that flag (bypass the Network Guard safety check), which is real added value the schema lacks; it stops short of saying when an agent should actually set 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?

States a specific verb and resource ("Lists ... port forwarding rules") and narrows scope to NAT Virtual Server rules on the cellular WAN interface. It does not name or contrast with sibling tools like router_add_port_forwarding or router_del_port_forwarding, so a reader must infer the read-vs-write split.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 word "active" and "Lists" imply this is a read/inspection call, which is enough to distinguish it in practice from the add/del siblings, but no explicit when-to-use or when-not guidance is given.

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

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

With no annotations, the description must carry the full burden. It does add useful information by saying force bypasses the 'Network Guard safety check,' which the schema alone doesn't convey. However, it doesn't explain what the bypass means for a read operation, or what permissions are needed, so the disclosure is partial.

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

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

It is two sentences with no filler, and the purpose is stated first. The Args block cleanly documents the single parameter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 don't need explaining. The one parameter is documented, and the tool's scope is clear. It could say more about why a read operation would need a safety bypass, but it is otherwise sufficient.

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

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

Schema description coverage is 0%, so the description must explain the only parameter, and it does: force is used to bypass the Network Guard safety check. It gives the parameter's meaning and effect, though not the default value.

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

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

It states a specific verb and resource: 'Retrieves the automated periodic reboot schedule settings.' That clearly distinguishes it from router_set_reboot_schedule and router_reboot. However, the description doesn't explicitly contrast those siblings, so it falls just short of a 5.

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

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

It gives no explicit when-to-use or when-not-to-use guidance, and it doesn't mention the nearby alternatives router_set_reboot_schedule or router_reboot. The only usage hint is indirect: 'Retrieves' implies a read 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. It discloses that data is 'real-time' (a genuinely useful trait), but never states that the tool is read-only/non-destructive, what the optional 'force' flag changes, whether the router must be reachable, or how a degraded/no-signal condition is reported.

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

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

Two sentences, front-loaded with the resource and metric list, with zero filler. The trailing geographic parenthetical (Malabe/SLIIT) is mildly superfluous but arguably contextualizes regional band behavior.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 explaining return values is unnecessary, and for a simple getter the description is close to sufficient. However, with no annotations, it leaves the mutation-safety profile and the 'force' switch undocumented, which is a real gap for an agent deciding how 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 0% and the sole parameter 'force' is completely unexplained in the description. A 'force' flag on a read operation strongly implies cache-bypass or retry-on-failure semantics, but the agent must guess which — this is exactly the gap the description should close.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Retrieves real-time 4G LTE RF signal metrics') and enumerates the exact metrics returned (RSRP, RSRQ, SNR, EARFCN, PCI, Signal Bars). The metric list implicitly separates it from the broader router_get_status, though it never names that sibling explicitly.

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

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

Gives a plausible use case ('guides router placement and antenna alignment for maximum 4G speed') but frames it as a benefit rather than a trigger condition. There is no guidance on when to prefer this over router_get_status, router_profile_check, or the tuning siblings like router_set_lte_band and router_set_cell_lock.

Agents often have multiple tools that could apply. Explicit usage 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 safety profile alone. It usefully discloses that force bypasses Network Guard SSID/Gateway validation, which is meaningful behavioral context, but it does not state permissions, side effects, or whether this read operation can be disruptive.

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

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

The description is short and front-loaded: the purpose appears in the first sentence and the single parameter is explained immediately after. No sentence is wasted.

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

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

Because an output schema exists, return fields need not be explained. The description covers the read nature and the force bypass, though it could be more complete by clarifying its relationship to router_get_rf_signal and when Network Guard validation matters.

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

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

Schema description coverage is 0%, so the description must explain the single parameter. It does so clearly: force bypasses Network Guard SSID/Gateway validation, which adds real meaning beyond the bare boolean schema.

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

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

States a clear verb and resource (retrieves device, cellular LTE, RF signal, and WAN status) and scopes it as a broad status snapshot. It does not explicitly distinguish itself from the sibling router_get_rf_signal, which overlaps on RF metrics, so it falls short of a 5.

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

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

Usage is implied by the broad 'full status' framing, but there is no explicit guidance on when to choose this over router_get_rf_signal or other status-related getters. It also does not say when the force bypass should or should not be used.

Agents often have multiple tools that could apply. Explicit usage 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 add real behavioral value by disclosing that force='bypasses Network Guard safety check' and that lines defaults to 50. However, it never states this is a non-destructive read, whether authentication/permissions are required, or how large result sets behave — meaningful gaps for a tool with zero annotation coverage.

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

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

Front-loaded with the purpose, then an Args block that is scannable and waste-free. The list format is appropriate for four parameters and nothing is padded, though it reads as auto-generated docstring prose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 read-only log fetch with an output schema present, so return-value detail is not required, and all four parameters are documented. What's missing is the safety/permission framing that the absence of annotations would otherwise leave the description to supply.

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

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

Schema coverage is 0%, so the description must compensate — and it largely does: each of the 4 params gets meaning, the default for lines, example values for module, and the full severity enum for min_level, none of which appear in the schema. Only minor gaps remain (module has no closed value list, lines has no upper bound).

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

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

States a specific verb and resource: 'Retrieves system and cellular event logs from the TP-Link router.' That cleanly separates it from the sibling router_clear_system_logs, though the contrast is left implicit rather than stated. An agent can identify what it does without opening the schema.

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

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

The filter parameters imply the intended usage (narrow by module or severity), but the description never says when to reach for this tool, when not to, or which sibling to use instead (e.g., for a status snapshot use router_get_status). Usage is inferable but not guided.

Agents often have multiple tools that could apply. Explicit usage 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; 'retrieves' implies a read-only operation and the Network Guard mention reveals a safety gate exists. However it never explains what Network Guard is, why the call would be blocked, or what changes when force=True — meaningful gaps for a tool with zero annotation coverage.

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

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

Two tight sentences with the resource list front-loaded and a compact Args block; nothing is padded. Slightly weakened by the unexplained jargon 'Network Guard' doing the work of the only behavioral disclosure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, and the read scope is clear. What remains thin is the safety-bypass semantics: for a tool with no annotations, an agent needs to know the risk of setting force=True and this is only named, not explained.

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

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

Schema coverage is 0% and the schema only says boolean default false, so the description must compensate. It does add real meaning — force bypasses a Network Guard safety check — but leaves 'Network Guard' undefined and gives no indication of consequences or when bypassing is warranted.

Input schemas describe structure but not intent. Descriptions should explain 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 (retrieves) and a concrete set of resources (system clock, time zone, DST, NTP server status), which is clearly distinguishable from siblings like router_set_dns or router_get_status. It does not, however, differentiate itself from router_sync_time, the sibling most likely to be confused with it.

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

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

There is no statement of when to call this versus router_sync_time, and no prerequisites or exclusions. The only usage-adjacent text is the note that force bypasses Network Guard, which explains a parameter but not when the tool itself 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 supplied, so the description carries the full burden; it does usefully disclose that a 'Network Guard safety check' exists and can be bypassed with force. However it does not say what Network Guard protects, whether bypassing it is risky, or whether the call is read-only and side-effect free, leaving the risk profile underspecified.

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

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

One front-loaded sentence states the purpose, followed by a compact args block. No filler, though the raw docstring 'Args:' formatting is slightly less scannable than prose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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. For a one-parameter read tool the coverage is near adequate, but with zero annotations the description leaves the safety-guard concept and the consequences of forcing unexplained, which is the one thing an agent could get wrong 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 coverage is 0% (the schema only says 'boolean, Force, default false'), and the description supplies the missing semantics: force bypasses the Network Guard safety check. That is real meaning beyond the structured field. It stops short of explaining what happens when the check is bypassed or when force is needed.

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

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

States a specific verb ('Retrieves') and specific resources (UPnP status and active dynamic port mappings), which clearly separates it from the mutating sibling router_set_upnp. It never names the sibling explicitly, so the get/set disambiguation rests on the tool name rather than the text.

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

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

There is no statement of when to use this versus router_get_port_forwarding or router_set_upnp, and no prerequisites. The only usage-adjacent hint is the 'force' arg note implying Network Guard may block the call, which is a condition but not guidance on alternatives.

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

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

No annotations are provided, so the description carries the full burden. 'Retrieves' implies a read, but nothing is said about whether 'force' triggers an active scan/re-query, whether results are cached, latency, or whether any permissions are required. For a diagnostic read on a router, that omission matters.

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

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

One tight sentence, front-loaded with the verb and the resource, with no filler. It is arguably too short given the unexplained parameter, but nothing in it is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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. The remaining gap is the 'force' parameter and any hint of when this is the right getter among many sibling getters — otherwise the definition is complete enough to call correctly in the default case.

Complex tools with many parameters or behaviors need more documentation. 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, and the description never mentions 'force' — its default, or what forcing does (re-poll the radio vs. return cached state). With one undocumented param, 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?

States a specific verb ('Retrieves') and resource (2.4 GHz and 5 GHz Wi-Fi radios) and enumerates what is returned: status, SSIDs, channels, operational state. It is distinguishable from sibling getters like router_get_rf_signal or router_get_guest_wifi by naming the radios explicitly, though it never contrasts itself with them.

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

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

No guidance on when to call this versus router_get_rf_signal, router_get_guest_wifi, or the mutating router_set_wifi_radio. The only interesting decision point — the 'force' flag — is not mentioned at all, so the agent has no basis for choosing a value.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that confirm is needed for mutations and that force bypasses a 'Network Guard safety check' — a meaningful behavioral signal. But it omits the effects of the operations (whether deleting a reservation disrupts a connected client, whether changes take effect immediately, permissions required), which matters 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?

A single front-loaded purpose sentence followed by a compact arg list; no filler. The Args block is slightly mechanical (repeating parameter names the schema already has) but each line adds constraint 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, and all parameters are described. What's missing is mutation-side context: no warning about disruption, no explanation of Network Guard's purpose, and no indication of reversibility or ordering constraints — gaps that matter for a destructive-capable tool with zero annotations.

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

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

Schema description coverage is 0%, so the description must compensate, and it does describe all five parameters with per-action conditionality and an example MAC format. It stops short of specifying IP format constraints or what 'confirm' actually gates, but the coverage is far better than the schema alone.

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

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

The description names a specific resource (static DHCP IP address reservations) and enumerates the three operations (add, delete, list), which lets an agent know exactly what domain it operates in. 'Manages' is a somewhat generic verb, but the Args block immediately disambiguates it into concrete actions.

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

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

It gives the action values and states which parameters are required per action (mac for add/delete, ip for add), which is real usage guidance. However, it never says when an agent should prefer this over other router configuration tools, nor when 'force' is appropriate versus dangerous, leaving the Network Guard decision unexplained.

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

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

No annotations are supplied, so the description carries the burden. 'Inspects' implies a read-only operation and the text explains the safety intent, but it doesn't say whether a failed check returns an error, a boolean, or a warning string, nor whether it blocks anything. That is real additional context, but the behavioral disclosure stays at a basic level.

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

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

Two short sentences: the purpose and what it inspects come first, and the prescriptive 'use before' guidance follows. No filler, and a reader gets the gist from the first line.

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

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

Since an output schema exists, the description doesn't need to explain return values, and with zero parameters the surface area is small. The remaining gap is that it never says how a negative result manifests to the caller. That matters for a pre-flight check, but it's a modest omission.

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

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

The tool takes no parameters, and the description correctly spends no space on argument semantics. The empty schema and 100% coverage mean there is nothing further to document.

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

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

The description gives a specific verb and resource: it inspects the host's network environment and names the fields it checks (SSID, Gateway). It implicitly distinguishes itself from siblings like router_get_status by scoping the check to the local host rather than the router itself, though it never names that sibling explicitly.

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

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

It states a clear usage context: call this before applying configuration changes, and it names the failure conditions to watch for (University Wi-Fi such as SLIIT, mobile hotspot). It doesn't point to an alternative tool for the case where the check fails, so it stops just short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuinely useful behavioral fact — that a "Network Guard safety check" exists and force bypasses it — but it never explains what that guard blocks, what happens if force is omitted, or whether reads have side effects on the inbox.

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

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

The purpose is front-loaded in a single sentence, followed by a compact Args block. The Args entries mostly restate the schema types, but the whole thing is short enough that no sentence is a real liability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, and all three optional parameters are documented. The only gap is the semantics of the Network Guard check that force interacts with, which leaves the agent guessing about the default safety posture.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: all three parameters are explained, including the allowed folder values ('inbox' or 'sent') which appear nowhere in the schema and would otherwise be free-form strings. Only the force parameter's consequences remain underspecified.

Input schemas describe structure but not intent. Descriptions should explain 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 ("Reads incoming or sent SMS messages from the router SIM inbox") and scopes it to the SIM-stored messages rather than device notifications. This cleanly separates it from the sibling router_send_sms, which is the only other SMS tool in the list.

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

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

The parenthetical "e.g. package expiry alerts" hints at a use case, and the force parameter implies there is a guard to work around, but there is no explicit statement of when to prefer this tool, no prerequisites, and no exclusions. Usage must be inferred from the name and context.

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

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

With no annotations, the description carries the full burden and does so: it discloses the destructive blast radius (host internet and Wi-Fi down 60-90 seconds), the confirmation gate required to execute, and the fact that 'force' bypasses a Network Guard safety check. These are exactly the behavioral traits an agent needs before invoking an irreversible, connectivity-severing action.

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

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

Front-loaded with the action and then an IMPORTANT warning, which is the right ordering for a destructive tool. The Args section repeats parameter names in full sentences and could be trimmed, but nothing is padded or irrelevant.

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

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

Output schema exists, so return values need no explanation, and the description covers impact, gate, and bypass. Remaining gap: it doesn't say whether the router reconnects on its own, whether in-flight sessions/settings survive, or what 'Network Guard' is protecting against.

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

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

Schema description coverage is 0%, so the Args section is doing real work: it explains 'confirm' as the safety gate that must be set True and 'force' as the bypass of Network Guard. That fully covers both parameters, though 'force' is left vague regarding what Network Guard actually blocks and what risks the bypass entails.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Initiates a graceful reboot of the TP-Link router'), and 'graceful' plus the immediate-impact framing separates it in spirit from router_set_reboot_schedule. It never names the sibling schedule tools, so the agent must infer that a one-off restart is this tool while recurring restarts belong elsewhere.

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

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

Gives the operative precondition explicitly ('You MUST provide confirm=True to execute') and warns that the host loses internet/Wi-Fi for ~60-90 seconds, which tells the agent the risk profile of calling it. It stops short of stating when to prefer this over alternatives such as router_set_reboot_schedule or router_run_diagnostic.

Agents often have multiple tools that could apply. Explicit usage 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 little beyond the checks performed. It does not say whether the test is disruptive (an NCSI reachability check can briefly affect the link), how long it takes, whether it needs an active WAN session, or whether results are cached. For an operational action on a live router, that 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?

One tightly written sentence that front-loads the action and follows with the specifics of what is verified. Nothing is padded and nothing needs to be moved earlier.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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-value explanation is not needed, and the purpose is fully covered. However, the unexplained 'force' flag and the absence of any disruption/duration/auth context leave real gaps for a live-network operation.

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

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

Schema description coverage is 0% for the single parameter, and the description never mentions 'force' at all. The agent is left to guess whether it re-runs a cached test, bypasses a cooldown, or overrides a safety check — none of which is stated.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Runs') and resource ('router-side diagnostic self-test') and enumerates exactly what is verified: physical link, WAN IP, Internet NCSI reachability. This is clearly distinguishable from read-only siblings like router_get_status or router_calibrate, though the description never names those alternatives explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 run this diagnostic versus simply calling router_get_status, nor any exclusions or prerequisites. The agent must infer that this is the connectivity-troubleshooting path rather than the routine status path.

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

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

With no annotations, the description does carry real weight: it reveals that a 'Network Guard safety check' exists and can be bypassed via force, which is valuable non-obvious behavior. However, it omits key traits — whether USSD sessions can be interactive/stateful, whether queries may incur carrier charges or mutate account state, and what happens when the guard blocks a 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?

One front-loaded sentence establishes the action, then a compact Args block. The Args lines restate schema field names but add meaning (examples, guard bypass), so little is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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-value explanation is not required, and the two parameters are covered. Still, for a tool that talks to the carrier and can bypass a safety mechanism with no annotations to lean on, the description should say more about failure modes and the implications of force.

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

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

Schema coverage is 0%, so the description must compensate, and it does reasonably: code is explained as a USSD string with concrete examples, and force is explained as a safety-check bypass. It falls short only on what the Network Guard actually checks and the risk of bypassing 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?

States a specific verb and resource ('Executes a USSD query on the cellular SIM card') and adds concrete example codes ('*344#' for Hutch quota, '*123#' for balance) that make the effect unmistakable. No sibling tool touches USSD, so the boundary is clear without comparison.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 examples imply the use case (checking balance/quota), but the description never states when to prefer this over siblings like router_get_data_limit, nor when it should not be used. It also doesn't explain when setting force=True is warranted beyond naming the Network Guard check.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that 'force' bypasses the Network Guard safety check, which is important context beyond the tool name, but it does not explain the consequences of bypassing the guard, whether SMS delivery is external or billable, 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 definition is short and front-loaded with the core action, followed by a compact parameter list. Every sentence and argument note adds useful semantic content, with no redundant restatement of the schema.

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

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

The output schema exists, so return-value documentation is not required, and all three parameters are explained. However, for an SMS-sending tool with no annotations, the definition omits important context about side effects, safety-check implications, and delivery 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%, so the description must define the parameters, and it does: 'to_phone' is the recipient phone number, 'message' is the text content, and 'force' bypasses the safety check. This compensates well for the schema's lack of property descriptions, though it does not specify phone-number format or message-length limits.

Input schemas describe structure but not intent. Descriptions should explain 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: sending an SMS message through the router SIM card. It is clearly distinct from the sibling router_read_sms, though it does not explicitly name alternatives or clarify scope beyond the core action.

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

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

There is no guidance on when to use this tool versus alternatives such as router_read_sms, nor are there prerequisites or conditions for sending. The description only implies usage from the verb 'Sends' and gives no exclusions or contextual triggers.

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

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

With no annotations at all, the description carries the full burden and does well: it warns that the cellular link momentarily drops and renegotiates, mandates confirm=True, and discloses that force bypasses the Network Guard safety check. What's missing is failure behavior (what happens if the cell is unreachable) and whether a lock survives reboot.

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

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

Purpose is front-loaded in the first sentence, the disruptive side effect is called out in an IMPORTANT block before the parameters, and each arg line earns its place given zero schema descriptions. The Args section slightly restates what the schema titles already show, but that repetition is justified 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-by-nature mutation with no annotations, the description supplies the safety gate, the disruption warning, the bypass flag's meaning, and every parameter's semantics; return values are covered by the existing output schema. An agent has enough to invoke it correctly and cautiously.

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

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

Schema coverage is 0%, so the description must document all five parameters — and it does, with concrete examples ('1550' for Band 3, '58') plus the non-obvious semantics of force (bypasses Network Guard) and confirm (required safety gate). This adds meaning well beyond the bare string/boolean schema types.

Input schemas describe structure but not intent. Descriptions should explain 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 pair (locks/unlocks) and a precise resource: the router's cellular cell lock keyed by EARFCN + PCI. That implicitly separates it from band-level siblings like router_set_lte_band, but no sibling is named explicitly, so differentiation is left to inference.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the lock/unlock condition ('enable: True to lock to cell, False to unlock (return to auto roaming)') and a hard prerequisite (confirm=True), which is real guidance. It never says when an agent should choose this over router_set_lte_band or router_get_rf_signal, and offers no when-not guidance.

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

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

With no annotations, the description carries substantial behavioral explanation: it notes that confirm is required to apply limits, enable enforces quota, and force bypasses a Network Guard safety check. It still does not describe reversibility, required permissions, or broader side effects, but it discloses the key safety-related behavior for this 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 description is front-loaded with a clear purpose sentence, followed by a compact Args block that earns its place by documenting all six otherwise-undocumented parameters. There is no redundant or wasted prose.

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

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

The tool has six parameters and no annotations, so parameter and safety documentation are critical; the description covers both well. An output schema exists, so return-value details are not required, but the description still lacks explicit routing to getter/alternative tools and broader side-effect details.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: every parameter is documented with meaning and examples or ranges, including limit_mb in MB, payment_day 1-31, warning_percent threshold, enable semantics, confirm requirement, and force bypass behavior.

Input schemas describe structure but not intent. Descriptions should explain 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: configuring monthly cellular data quota, billing-day reset, and alert threshold. It clearly distinguishes itself from the sibling getter by using the configuration/action framing, though it does not explicitly name router_get_data_limit as the read-only alternative.

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

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

Usage is implied by the action-oriented purpose and the presence of confirm/force flags, but the description does not explicitly say when to use this tool versus router_get_data_limit or other router configuration tools. There are no exclusions or prerequisites beyond parameter-level notes.

Agents often have multiple tools that could apply. Explicit usage 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 load, and it does usefully disclose that `force` bypasses a 'Network Guard' safety check and that `confirm` is needed to modify DMZ. However, it doesn't state the security implication of enabling DMZ (the internal host is fully exposed to unmapped inbound traffic), whether confirm must be true for changes to apply, or what happens if ip_address is omitted.

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

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

Purpose is front-loaded in one sentence, followed by a compact Args block with no filler. The Args formatting is slightly verbose but every line conveys parameter meaning.

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

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

For a mutation tool with no annotations and no schema field descriptions, the description covers the essentials but omits key behavioral facts: DMZ exposure risk, the role of the confirm gate, and the relationship to router_get_dmz. An output schema exists, so return values need not be described.

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

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

Schema coverage is 0%, so the description must compensate, and it does define all four parameters. Gaps remain: the semantics of `confirm` (is it mandatory? what does it gate?) are ambiguous, and the behavior of the default-empty `ip_address` when disabling is not explained.

Input schemas describe structure but not intent. Descriptions should explain 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 opens with a specific verb+resource: it enables or disables DMZ host forwarding to an internal IP. That clearly distinguishes it from the read counterpart router_get_dmz, but the description never names the sibling or that router_get_dmz shows current state.

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

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

The description implies when to use it (to route all unmapped inbound traffic to one host), but it gives no explicit guidance on when to use this versus port forwarding (router_add_port_forwarding) or when to check state first with router_get_dmz. The `force` note hints at a precondition but doesn't state the normal path.

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

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

With no annotations, the description carries the full load. It usefully discloses an internal safety gate ('Network Guard') and how to bypass it, which is real behavioral context. It does not say whether the change is immediate or requires a reconnect, whether it is reversible, what Network Guard actually blocks, or what happens on invalid IPs.

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

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

One front-loaded sentence establishes the operation, followed by a compact Args block with no filler. Every line carries information; only the redundant 'default 8.8.8.8' duplication with the schema is mildly wasteful.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 an unannotated mutation tool that rewrites WAN DNS, the description omits blast-radius information: whether existing connectivity drops, whether the router validates the resolvers, and what Network Guard protects against. Adequate but with a clear safety-context gap.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains primary_dns with concrete examples (8.8.8.8, 1.1.1.1), states secondary_dns's default, and explains that force bypasses a safety check rather than restating its type. It stops short of describing IP format/validation rules.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Configures custom DNS resolvers on the router's WAN connection.' The WAN-scoping detail is beyond what the name conveys. No sibling tool touches DNS, so there is nothing to disambiguate against explicitly.

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

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

Usage is implied by the purpose, and the description does give one useful conditional (set force=True to bypass the Network Guard safety check), but it never says when to prefer this tool over e.g. router_set_wifi_radio or the other configuration tools, nor what prerequisites exist.

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

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

With no annotations, the description carries the full burden and does add real context: 'force' bypasses a named 'Network Guard' safety check, 'allow_lan' toggles guest isolation, and password rules are spelled out. It still omits whether disabling kicks connected guests, whether changes are reversible, and what a non-confirmed call actually does.

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

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

The one-line purpose sits up front followed by a compact Args list, so an agent can scan to the field it needs. The Args block is essentially re-documentation of the schema, but since the schema has zero coverage, no sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 7-parameter, zero-required mutation tool with no annotations, the description covers every field's meaning and the safety-flag behavior, and an output schema exists so return values need no explanation. What's missing is the operational contract: what 'confirm' gates, what an omitted field does to live state, and whether the router must be in a particular mode first.

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

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

Schema coverage is 0% (bare types and defaults only), so this description does the heavy lifting: it supplies the band enum values ('2.4GHz', '5GHz', 'both'), the password length/open-network rule, and the isolation semantics of allow_lan, none of which are in the schema. It falls short of 5 because the all-optional null defaults for ssid/password/allow_lan are never resolved (keep existing vs. clear), which is exactly what an agent needs to know.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Configures or toggles dual-band Guest Wi-Fi networks and local LAN isolation'), which cleanly separates it from router_get_guest_wifi (read) and router_set_wifi_radio (main radio). It never names those siblings explicitly, so the differentiation is implied rather than stated.

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

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

There is no guidance on when to use this versus router_get_guest_wifi (to inspect first) or router_set_wifi_radio, and no prerequisites are stated. The presence of a 'confirm' flag hints at a two-step apply flow, but the description never explains when confirm must be true or what happens to an existing guest network when it is omitted.

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

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

With no annotations, the description carries full behavioral burden. It does add real value by disclosing that `force` bypasses a 'Network Guard safety check', a non-obvious safety gate, but it omits key behavioral facts: whether disabling removes the schedule or merely pauses it, whether settings persist across reboot, and whether midnight-spanning windows are handled. An output schema exists, so return values need not be covered.

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

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

The purpose is front-loaded in one sentence, followed by a compact Args block with no filler. The argument restatements overlap somewhat with schema titles but consistently add meaning rather than duplicating types.

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

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

For a 4-parameter mutation tool with no annotations and an output schema, the description covers purpose and parameters adequately but leaves behavioral questions unresolved — notably what `enable: false` does to an existing schedule and how overnight windows are interpreted. Enough to call it, not enough to predict its effects confidently.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: each of the four parameters is documented, including 'HH:MM' format with concrete examples, the direction of each boundary (start = LEDs off, end = LEDs back on), and the meaning of `force`. It stops short of stating defaults for start_time/end_time (they live in the schema only) or what start_time/end_time do when `enable` is false.

Input schemas describe structure but not intent. Descriptions should explain 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 first sentence gives a specific verb (configures) plus resource (night mode for router front panel LEDs) and states the effect (LEDs turned off automatically during sleeping hours). It is clearly distinguishable from read-side siblings such as router_get_led_status, though it does not name any sibling explicitly.

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

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

Usage is only implied: the enable/start_time/end_time semantics make the scheduling intent obvious, but there is no explicit statement of when to use this versus router_get_led_status or other LED controls, and no when-not guidance. The `force` note hints at a prerequisite (Network Guard) without explaining when bypassing 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?

With no annotations, the description carries the full burden and does disclose important behavior: changing bands triggers cellular radio renegotiation, confirm must be True to execute, and force bypasses a Network Guard check. It still lacks details such as required permissions, expected downtime, or reversibility beyond setting 'auto'.

Agents need to know what a tool does to the 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 front-loaded with the core action and examples, then adds a relevant warning and parameter semantics. The Args block is slightly redundant with the schema but still efficient and not padded.

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

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

The output schema means return values need not be explained, and the description covers the key mutation warning and safety flags. For a no-annotation mutation tool, however, it should more fully cover prerequisites, side effects, and what happens when confirm is omitted.

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

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

Schema description coverage is 0%, so the description must compensate. It does so for all three parameters: band values including 'auto', confirm as the execution safety flag, and force as the Network Guard bypass, adding meaning beyond the bare schema.

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

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

The description states a specific verb and resource: manually locking the router to a specific LTE band, with concrete band examples and 'auto'. It is clear what the tool does, though it does not explicitly distinguish itself from the sibling router_set_cell_lock.

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

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

It gives a usage context by mentioning optimal Hutch/Dialog 4G towers in Sri Lanka, which implies when the tool is useful. However, it does not state when to use this instead of router_set_cell_lock or when not to use it, leaving alternative selection to inference.

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

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

No annotations are provided, so the description must carry the behavioral burden. It usefully discloses the confirm flag and that force bypasses the Network Guard safety check, but it does not mention reboot-related downtime or other side effects.

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

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

The purpose is front-loaded in one clear sentence, followed by a compact Args list that is justified by the 0% schema description coverage. There is no filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 7-parameter mutation tool with no annotations but an output schema, the description is largely complete: it covers all parameters and safety flags. It could still be improved by naming the immediate reboot sibling or warning about scheduled downtime.

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

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

Schema description coverage is 0%, so the description must explain all seven parameters. It does so thoroughly: enabled, hours, minutes, mode, day_of_week mapping, confirm, and force are each given clear semantics, ranges, defaults, or enum-like values.

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

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

The description uses a specific verb and resource: it configures or disables automated daily or weekly periodic router reboots. The word 'periodic' and 'schedule' clearly distinguish it from an immediate reboot tool, even without naming a sibling.

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

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

Usage is implied by the tool name and purpose, but the description does not explicitly say when to use this instead of router_reboot or router_get_reboot_schedule. It also does not clarify prerequisites for applying a schedule beyond the confirm flag.

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

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

With no annotations, the description carries the full burden. It does disclose two valuable traits: confirm is needed to modify UPnP, and force bypasses a 'Network Guard safety check' — which signals this is a guarded mutation. It stops short of saying what happens if confirm is omitted (error? silent no-op?), whether UPnP enablement is a security exposure, or what a success response looks like.

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

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

One front-loaded sentence stating the action, followed by a tight three-line argument list. Nothing redundant, no filler.

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

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

An output schema exists, so return values needn't be explained, and all params are covered. But for an unannotated mutation tool guarded by a safety check, the description should say what confirm actually guards against and what failure looks like — that gap matters for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all three parameters are explained (enabled toggles state, confirm gates the modification, force bypasses the safety check). It omits the defaults for confirm/force and whether confirm=false simply fails, but coverage is otherwise complete.

Input schemas describe structure but not intent. Descriptions should explain 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 pair and resource: enabling/disabling UPnP dynamic port forwarding on the router. That clearly separates it from the read-only sibling router_get_upnp, though the description never names the sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 versus router_get_upnp or the manual port-forwarding tools (router_add_port_forwarding). The only usage-adjacent content is what the confirm and force flags do, which is parameter guidance rather than tool-selection guidance.

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

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

With no annotations at all, the description carries the full burden and does substantial work: it discloses the self-disconnect hazard, the confirm gate, and that force bypasses a Network Guard safety check. It omits persistence behavior (does the radio/SSID change survive reboot?) and any auth/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 destructive warning is front-loaded immediately after the one-line purpose, then parameters are listed compactly. Every line does work — nothing duplicates structured data because the schema documents none of these parameters.

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

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

For a mutating radio tool with five undocumented-in-schema parameters, the description covers purpose, hazard, and all parameter meanings, and an output schema exists so return values need not be explained. The remaining gap is post-change behavior (reboot requirement, effect on connected clients) which an agent would want before calling.

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

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

Schema coverage is 0% and the schema has no enums, but the Args block supplies the exact band literals ('2.4GHz' or '5GHz'), the semantics of enable, the optionality of ssid, the purpose of confirm, and what force actually bypasses. This adds genuine meaning the schema cannot convey.

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

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

The first sentence states a specific verb pair plus resource and scope ("Enables or disables a Wi-Fi radio (2.4GHz or 5GHz) and optionally updates its SSID"). It is clearly distinguishable from read-side siblings like router_get_wifi_networks and from router_set_guest_wifi, though neither sibling is named explicitly.

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

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

Gives a concrete precondition (confirm=True is mandatory) and an explicit hazard condition (disabling the band you are connected to drops the host). It stops short of naming alternatives such as router_set_guest_wifi or stating when to prefer them, so it is strong but not complete.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral disclosure burden. It usefully states that force bypasses a Network Guard safety check, but it does not explain what that check protects against, whether the action is reversible, or what side effects the synchronization may have.

Agents need to know what a tool does to the 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 front-loaded with the main action and followed by a compact explanation of the single argument. There is no redundant or wasted text.

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

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

The tool is simple, has one optional parameter, and includes an output schema, so return values need not be described. The description covers the core action and the safety-bypass flag, though it could say more about the consequences of bypassing Network Guard.

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

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

Schema description coverage is 0%, so the description must explain the sole parameter, and it does: force=True bypasses the Network Guard safety check. It could still elaborate on what Network Guard is or when bypassing it is appropriate, but the core semantic is clear.

Input schemas describe structure but not intent. Descriptions should explain 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: triggering an immediate NTP network time synchronization on the router. This clearly distinguishes it from the sibling router_get_time, which retrieves time rather than synchronizing it.

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

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

The description implies when to use the tool by saying it triggers an immediate synchronization, but it does not explicitly compare it with alternatives such as router_get_time or state when not to use it. Usage is therefore inferable but not fully guided.

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

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

With no annotations, the description carries the full burden. It usefully discloses that a 'Network Guard safety check' exists and that force bypasses it, which is real behavioral context. But it never says whether toggling drops the cellular connection, whether the setting survives reboot, or what the safety check verifies — gaps that matter 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?

Three short, front-loaded sentences: an action summary, a usage recommendation, then arg docs. No filler, though the enable arg line mostly restates the obvious from the first sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 are covered. For an unannotated mutation tool, however, the description should address disruption to the connection and persistence of the setting, neither of which it does.

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

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

Schema description coverage is 0%, so the description must document both params, and it does: enable (True enable / False disable) and force (bypass Network Guard safety check). The meaning of force is explained beyond its bare name, though the consequences of bypassing the guard remain unstated.

Input schemas describe structure but not intent. Descriptions should explain 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 pair (enables/disables) against a specific resource and scope (the IPv6 stack on the cellular connection). No sibling touches IPv6, and the cellular-connection qualifier keeps it from being confused with general Wi-Fi or DNS tools.

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

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

Gives a concrete condition for using the disable path: 'Disabling IPv6 is recommended if Hutch IPv6 routing is introducing dual-stack timeout delays.' It does not state when not to use the tool (e.g., when IPv6 is required by the carrier), so it stops short of full routing guidance.

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