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

The description only restates the action and does not disclose behavioral details such as what happens if the entry already exists, whether duplicate entries are created, or whether the change is persistent. The annotations indicate idempotentHint=false and destructiveHint=false, but the text adds no additional behavior beyond the name.

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

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

The description is very concise, but its brevity crosses into under-specification. It repeats the title rather than front-loading useful semantic information; there is no structural helpful text such as expected combination of 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?

With six nullable parameters and no required fields, the description is incomplete. It doesn't explain what a valid target entry looks like, how TTL or comment behaves, or how address/cname/regexp are meant to be combined. Although an output schema exists, the input semantics are insufficiently 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?

The description provides no parameter semantics. Schema gives useful descriptions for name, cname, regexp, and address, but ttl and comment are unexplained, and the description doesn't clarify important constraints like how name, cname, regexp, and address interact or whether certain combinations are required/optional.

Input schemas describe structure but not intent. Descriptions should explain 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 'Add a static DNS entry.' is essentially a restatement of the tool name (add_dns_static) and title ('Add Static DNS Entry'). It adds no conceptual distinction or details about what a static DNS entry entails or how it relates to siblings such as list_dns_static or remove_dns_static.

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

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

The description gives no guidance about when to use this tool versus the many sibling tools (e.g., list_dns_static, remove_dns_static, make_lease_static). It provides no context for when this operation is appropriate, or when it should be avoided in favor of another tool.

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

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

Annotations only indicate openWorldHint=false, idempotentHint=false, destructiveHint=false, so no readOnly hint. The description discloses that firewall ordering is first-match-wins and warns about the dead-code consequence of poor placement. This goes beyond annotations by explaining the behavioral impact of rule position, which is critical for correct usage.

Agents need to know what a tool does to the 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 exceptionally concise: two short paragraphs. It front-loads the core purpose, then delivers the critical ordering guidance with a concrete example ('appended after a final drop'). Every sentence adds value, and there is no fluff 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?

Given the tool's complexity (19 parameters), the description covers the most important risk (ordering) but leaves many parameter semantics unexplained. It does not mention what the return value looks like (though an output schema exists) or how to construct a rule beyond the ordering advice. The agent would need to rely heavily on schema descriptions and domain knowledge for the rest, which is incomplete at 32% coverage.

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

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

Schema description coverage is only 32%, and many parameters (dst_port, src_port, protocol, addresses, interfaces, etc.) have no descriptions in the schema. The tool description only addresses place_before, explaining its purpose and default behavior. It does not compensate for the large number of undocumented parameters, leaving the agent to infer semantics from names 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 clearly states the action ('Add a firewall filter rule') with a specific verb and resource. It distinguishes itself from sibling tools like add_nat_rule by explicitly mentioning 'firewall filter rule', and from update/remove/move tools by the verb 'Add'. The additional context about rule ordering further clarifies its purpose in the firewall context.

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

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

The description gives explicit guidance on when to set place_before, explaining that appending after a final drop makes the rule dead code. This is valuable usage context. However, it does not explicitly state alternatives like 'use update_firewall_rule for existing rules' or when to prefer this over other add tools, though the purpose makes that somewhat implicit.

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

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

The description adds valuable behavior beyond the annotations: it warns that a port forward alone may not work unless the forward chain permits dstnat traffic, and directs the user to check list_firewall_rules before troubleshooting. This is context not captured by idempotentHint, destructiveHint, or openWorldHint, and it helps set proper expectations after the call.

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

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

The description is compact, front-loaded with the core purpose, and every sentence earns its place. The second sentence adds a high-value troubleshooting note about the forward chain precondition without bloat.

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

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

For a mutation tool with 13 parameters and a low schema coverage, the description is incomplete. It does not explain the required parameters' roles, common combos, or the effect of omitting optional fields. While the output schema covers return values, the description leaves too much operational context to inference.

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

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

The description provides almost no parameter-level guidance; it only mentions 'port forward' generically. With 13 parameters and only 31% schema description coverage, the description needed to compensate by explaining key fields like dst_address, in_interface, protocol, and to_ports, but it does not. The schema's few descriptions carry the entire parameter-semantics burden.

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

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

The description clearly states the tool adds a NAT rule, with 'port forward' as an example. This distinguishes it from sibling tools like add_firewall_rule because the resource is explicitly a NAT rule, not a firewall rule. The verb 'Add' plus the resource gives a specific, unambiguous purpose.

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

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

The description conveys the primary use case (adding a NAT rule, especially a port forward) and adds a useful follow-up check about the forward chain. However, it does not explicitly contrast this tool with alternatives like add_firewall_rule or remove_nat_rule, nor does it state when not to use it.

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

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

Annotations already establish readOnlyHint=true and idempotentHint=true. The description adds useful behavioral context beyond those hints by specifying that the tool performs a reachability and authentication check, which is meaningful for an agent deciding whether this action matches its intent.

Agents need to know what a tool does to the 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 concise sentence states the core purpose with no filler. Every word earns its place, and the essential outcome is immediately clear.

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

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

For a zero-parameter, read-only, idempotent check with an output schema and rich annotations, the description is sufficient. Nothing critical is missing for an agent to select and invoke the tool correctly.

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

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

The tool has zero parameters, so the schema leaves no ambiguity. The description does not need to document parameters, and the baseline of 4 applies because there is nothing for it to explain.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Confirm') and names the exact resource/relationship: the hub's reachability and authentication to this device. This clearly distinguishes the tool from siblings like 'system_info' or 'list_interfaces' that perform different read-only inspections.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the tool should be used when verifying whether the hub can communicate with and authenticate to the target device. However, it does not explicitly mention alternatives or conditions for when not to use this tool, leaving some room for inference.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the specific detail that counters are included, which is useful but minimal. It does not disclose pagination, performance characteristics, or any additional behavioral quirks, but given the annotations, the burden is lower.

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

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

The description is a single, compact sentence that conveys the core purpose without any filler. It is front-loaded with the essential information and no unnecessary words. Highly efficient.

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

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

Given the tool's simplicity (one parameter, output schema present, read-only annotations), the description is mostly sufficient. It tells the agent it returns all fields of one rule including counters. It does not explicitly mention that the output is a single object, but that is implied by 'one firewall rule'. The presence of an output schema fills any gaps about return structure.

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

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

Schema coverage is 100% and the parameter rule_id has a clear description ('The rule id from list_firewall_rules, e.g. *7'). The tool description adds no additional parameter information beyond the schema, which already provides the necessary context. The baseline of 3 is appropriate.

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

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

The description states 'Every field of one firewall rule, including counters' – a specific resource (firewall rule) and scope (all fields) with a distinguishing detail (counters). It clearly separates this from list_firewall_rules (which lists many) and mutation tools. The verb is implied by the name, but the purpose 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?

The description itself does not explicitly state when to use this tool vs alternatives. However, the parameter description for rule_id says 'The rule id from list_firewall_rules', which implies the typical workflow: first list rules to get an ID, then fetch full details. This is helpful but not explicit about when to choose this over list_firewall_rules or other tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the operation's safety profile, which lowers the bar. The description adds one genuinely useful behavior - logs are returned with the most recent entry last - but does not disclose truncation at the 500-entry limit, default behavior when no filters are set, or log retention scope. No contradiction with annotations.

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

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

One short sentence with zero filler. The core action is front-loaded ('Read the device log') and the ordering note is appended efficiently. 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?

The context is strong overall: 100%-covered schema handles all three optional parameters, readOnly/idempotent annotations handle safety, and an output schema exists so return values need not be described. The description completes the picture with ordering behavior. The only gap is the lack of explicit selection guidance relative to system_info/ros_list, a minor omission given the log resource is unique among siblings.

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

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

Schema description coverage is 100%: limit ('Most recent N entries'), topic ('Filter by RouterOS log topic...'), and search ('Case-insensitive substring match') are all individually documented in the schema. The description adds no parameter-level meaning beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb ('Read') and resource ('the device log'), plus an ordering detail ('most recent last'). No sibling tool handles the device log, so scope is effectively unambiguous and it can be told apart from siblings like list_firewall_rules and list_dhcp_leases. It stops short of explicitly contrasting with any sibling, which keeps it just below 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?

Provides no guidance on when to use this tool versus alternatives, and no prerequisites or exclusions. The intended usage is only implied - an agent must infer this is the tool for log reading. Given nearby siblings like system_info and ros_list that could plausibly be reached for 'check the logs', explicit routing guidance would materially help but is absent.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to restate safety. The description adds a little context by framing the result as a network inventory, but it does not disclose additional behavioral traits such as filtering semantics, lease types, or whether only dynamic leases are included.

Agents need to know what a tool does to the 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 one short, front-loaded sentence that names the operation and adds a helpful mental model. Every word earns its place with 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 simple read-only list tool with an output schema and strong annotations, the description is nearly complete. It could be improved by noting when to prefer sibling tools or clarifying what 'active_only' filters, but the core context needed to call the tool correctly is present.

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

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

Schema description coverage is 50%: 'search' is described in the schema, but 'active_only' has no description. The tool description does not add any parameter-level meaning, though the parameter names and defaults are fairly self-explanatory. With partial schema coverage and no description compensation, this is adequate but not strong.

Input schemas describe structure but not intent. Descriptions should explain 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 action and resource: 'List DHCP leases', and adds a useful conceptual gloss ('effectively the inventory of what is on the network'). It does not explicitly contrast itself with sibling tools like list_ip_addresses, so it misses the top score, but the purpose 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?

The 'inventory of what is on the network' phrasing implies a use case: when you need to see what devices are currently known via DHCP. However, the description gives no explicit guidance about when to choose this over sibling tools such as list_ip_addresses or list_dns_static, so usage guidance is only implied.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and idempotentHint=true, so the safe read-only behavior is well covered outside the description. The description is consistent with these hints but adds no extra behavioral context such as pagination, authorization, or side effects. No contradiction exists.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to clarifying what the tool does.

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

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

For a zero-parameter, read-only, idempotent list tool with an output schema and strong annotations, the description is nearly complete. It does not explain what 'regex overrides' are or provide explicit alternative routing, but those gaps are minor given the structured context already available.

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

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

The tool has zero parameters and 100% schema description coverage, so there is no parameter ambiguity for the description to resolve. The zero-parameter baseline of 4 applies.

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

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

The description states a specific verb ('List') and a specific resource ('static DNS entries and regex overrides'), making its purpose immediately clear. It also distinguishes itself from the write-oriented siblings add_dns_static and remove_dns_static.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 read-only 'List' verb implies use when static DNS/regex configuration needs to be retrieved, but the description does not explicitly state when to choose it over other list tools or write siblings. Usage is implied rather than explicitly 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered structurally. The description adds meaningful behavioral context beyond that: rules appear in evaluation order, and positions shift with mutations. This is useful for an agent planning subsequent add/remove/move calls. No contradiction with annotations.

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

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

Two short paragraphs with zero fluff. The first sentence delivers the primary purpose, and the second adds a crucial operational caveat about id vs position. Everything earns its place, and the structure is easy to scan.

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

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

For a read-only list tool with a full output schema and strong annotations, the description covers the key gotcha an agent needs to know (id is stable, position is not). It doesn't explicitly mention return ordering beyond evaluation order, but the output schema covers field details. The description is sufficient for correct invocation and downstream use.

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

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

Schema description coverage is 100%, so chain, verbose, and include_dynamic are already well-documented in the schema. The description does not add parameter-specific semantics beyond what the schema provides; the id/position note concerns output, not parameters. A baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('List firewall filter rules') and qualifies with 'evaluation order', which adds precision and distinguishes it from list_nat_rules and get_firewall_rule. The phrase 'filter rules' also separates firewall filtering from NAT rules, making the tool's scope unambiguous without opening schemas.

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

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

The description gives clear operational context: rules are listed in evaluation order, and the id/position distinction is explicitly tied to future modifications. It doesn't name alternatives like get_firewall_rule for single-rule lookups, but the list-vs-get distinction is implicit. There are no exclusions or when-not-to-use instructions, so it just misses the explicit-alternatives bar.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the read-only, safe nature is covered. The description adds the 'every interface' scoping (no hidden default filtering) and lists the returned fields, which is useful context. It does not go deeper into behavior like pagination or result size limits, but given the annotation coverage, this is acceptable.

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

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

The description is a single, efficient sentence that front-loads the action and resource. Every word earns its place: 'List every interface' sets scope, and the field list specifies the expected output. No filler or redundancy.

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

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

Given the tool's simplicity and the presence of an output schema, the description is mostly sufficient. The main gap is the meaning of running_only, which is neither explained in the schema nor the description. Since the tool has only two optional parameters and the default behavior is clear from 'every interface', this is a moderate gap rather than a critical one.

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

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

Schema description coverage is only 50%, with type_filter explained but running_only left undocumented. The tool description does not compensate: it mentions 'running state' as a field but never explains that running_only filters to only running interfaces. The description adds no meaning beyond the schema, and the schema itself is incomplete for running_only, so an agent may misuse the parameter.

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

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

The description uses a specific verb ('List') with a clear resource ('every interface') and names the exact fields returned (type, MAC, MTU, running state). It is immediately distinguishable from sibling list tools like list_ip_addresses and list_firewall_rules, so an agent can tell 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 description implies usage: call this when you need to enumerate interfaces and their attributes. However, it provides no explicit guidance on when to use it versus alternatives (e.g., list_ip_addresses) or when to apply the type_filter/running_only parameters. There are no exclusions or alternative suggestions, leaving the agent to infer context from the name and siblings.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe read operation. The description adds modest context by specifying 'configured' addresses, implying persistent configuration rather than dynamic or transient data. No behavioral disclaimer beyond what annotations provide is included, which is acceptable given the simple listing nature.

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

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

A single, front-loaded sentence that conveys both the primary purpose and the key output relationship. Every word earns its place with no redundancy or 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?

Given the tool's zero parameters, the presence of an output schema, and annotations covering read-only/idempotent behavior, the description is complete for an agent to select and invoke it correctly. Nothing important is missing.

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

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

The tool has zero parameters, so the description does not need to explain parameter meaning. The baseline of 4 applies because no parameter semantics are required and the tool schema is empty.

Input schemas describe structure but not intent. Descriptions should explain 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 ('List'), a specific resource ('configured IPv4 addresses'), and clarifies the relationship to interfaces ('and the interfaces they sit on'). This clearly sets it apart from siblings like list_interfaces and list_routes.

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

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

No guidance is given on when to use this tool versus alternatives. It does not mention siblings, exclusions, or scenarios where another tool would be preferred. The only implied signal is the tool name and the description's phrasing, which is not explicit.

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

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

Annotations already establish read-only and idempotent behavior, so the description only needs to add extra behavioral context. It does so by noting that rules are returned in evaluation order, which is especially relevant for NAT matching, and by clarifying that port forwards are included. No contradiction with readOnlyHint.

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

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

One short, front-loaded sentence with no filler. The verb, resource, scope, and evaluation-order detail are all present and nothing else 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 read-only list tool with an output schema and strong annotations, the core context is covered: what is listed, the scope, and the ordering. The lack of parameter guidance and usage routing is a minor gap, but the low complexity and existing structured metadata make the definition mostly complete.

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

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

The description does not mention chain or verbose, and with only 50% schema coverage the burden was on the description to clarify them. The schema documents chain as 'srcnat' or 'dstnat', so that parameter is recoverable, but the description adds no meaning about how filtering or verbosity affects the output.

Input schemas describe structure but not intent. Descriptions should explain 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 the operation explicitly ('List NAT rules') and adds two distinguishing details: scope ('including port forwards') and ordering ('in evaluation order'). This separates it from list_firewall_rules and from NAT mutation siblings like add_nat_rule.

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

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

The description implies read-only enumeration of NAT configuration but gives no explicit direction on when to choose this tool over list_firewall_rules or the NAT mutation tools. No exclusions or alternative conditions are stated.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. However, the description adds no additional behavioral context—it does not disclose whether the full table is returned by default, whether active_only changes the result set, or any performance or permission considerations. The phrase 'IPv4 routing table' merely restates the tool's scope.

Agents need to know what a tool does to the 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 one short, front-loaded sentence with no filler. It earns its place by stating exactly what the tool does, making it appropriately concise.

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

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

Given the tool's simplicity (one optional boolean parameter, read-only, output schema present), the description still falls short because it fails to explain the parameter's effect or any filtering behavior. Without reading the schema, an agent cannot know that active_only defaults to false or what it filters. The output schema likely describes the return shape, but the description is incomplete 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 explain the active_only parameter, but it does not. An agent cannot infer what 'active_only' means (e.g., only routes that are currently up) from the description, leaving the parameter's semantics entirely to the schema's property name.

Input schemas describe structure but not intent. Descriptions should explain 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 the specific verb 'List' and clearly identifies the resource as the 'IPv4 routing table', which distinguishes it from sibling tools like list_ip_addresses and list_interfaces. The tool's purpose 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?

The description provides no guidance on when to prefer this tool over alternatives such as list_ip_addresses or list_interfaces. There is no mention of context, prerequisites, or exclusions, so an agent receives no decision support beyond the purpose statement.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the tool is known to be safe and repeatable. The description adds behavioral context by explaining the effect (device keeps its address) and that it applies to dynamic leases. This provides value beyond the structured fields without contradiction.

Agents need to know what a tool does to the 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 written sentence with no fluff. It front-loads the action and purpose, making it immediately clear what the tool does.

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

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

For a simple two-parameter tool with annotations covering idempotency and safety, and an output schema presumably providing return info, this description is largely complete. It covers the core purpose and effect. Minor gaps (e.g., comment usage) are not critical given the simplicity and existing schema hints.

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

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

The description does not mention any parameters. The schema covers lease_id with a description (from list_dhcp_leases), but comment has no description, and schema coverage is only 50%. Since coverage is moderate and the description adds nothing about parameters, the agent lacks full understanding of parameter semantics (e.g., what comment is for).

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

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

The description states a specific action ('Pin') on a specific resource ('a dynamic DHCP lease') with a clear outcome ('so the device keeps its address'). This distinguishes it from siblings like list_dhcp_leases (which lists) and add_dns_static (which handles DNS), making the tool's purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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: when you have a dynamic DHCP lease you want to keep a fixed address. It does not explicitly mention alternatives or exclusions, but the context of 'dynamic lease' vs. static is understood. No prerequisites are stated, though the schema hints at getting the lease id from list_dhcp_leases. This is adequate but lacks explicit guidance.

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

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

The description adds valuable behavioral context beyond annotations: the move is specified by ids rather than positions, so it remains meaningful even if the rule list has changed since last read. This complements destructiveHint=true without contradicting it.

Agents need to know what a tool does to the 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 core action and followed by a meaningful clarification about id-based positioning. Every sentence earns its place; there is no filler or redundancy.

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

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

For a simple two-parameter mutation tool with full schema coverage and an output schema, the description is nearly complete. It explains the non-obvious id-relative behavior, leaving only an explicit usage guideline as a minor gap.

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

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

Schema description coverage is 100%: both rule_id and before_rule_id are fully described with their meaning, including the omission behavior for before_rule_id. The description adds a useful semantic framing around id-based movement, but does not need to add parameter-level details.

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

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

The description clearly identifies the action as 'Reorder a firewall rule relative to another rule.' The verb 'reorder' plus the resource 'firewall rule' distinguishes it from sibling tools like update_firewall_rule, set_firewall_rule_enabled, and remove_firewall_rule.

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

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

Usage is implied by the action word 'reorder', but the description does not explicitly state when to use this tool versus alternatives such as update_firewall_rule or add_firewall_rule. There are no explicit exclusions or alternative routing, but a competent agent can infer the intended use.

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

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

The description's 'Delete' matches the annotation destructiveHint=true, so there is no contradiction. However, it adds little beyond the annotations: the destructive and idempotent hints are already provided in structured data, and the description does not disclose additional behavioral context such as permanence, cascading effects, or how deletion of an arbitrary static DNS entry is handled.

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

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

The description is a single concise sentence that states the operation immediately. It contains no filler, preamble, or redundant detail and earns its place in the definition.

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

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

Given the low complexity of a single-parameter destructive tool, an output schema, and the annotations covering destructive/idempotent behavior, this description is mostly complete. The only notable gap is not pointing the agent to list_dns_static for finding a valid entry ID, but that is a minor convenience rather than a blocking 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 schema has 0% description coverage for the parameter, but the description does not compensate by explaining what entry_id refers to or how it should be obtained. The parameter name itself suggests identity, but the description goes no further than repetition of the resource noun.

Input schemas describe structure but not intent. Descriptions should explain 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, 'Delete', and a specific resource, 'a static DNS entry,' so the tool's exact purpose is immediately clear. It is easily differentiated from sibling tools like add_dns_static, list_dns_static, remove_nat_rule, and remove_firewall_rule without needing to inspect their schemas.

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

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

The description states the core use case: deleting a static DNS entry. While it does not mention the natural companion tool list_dns_static for finding an entry_id, the resource domain is specific enough that an agent will know when this tool is intended and when it is not.

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

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

Annotations already mark destructiveHint=true and idempotentHint=true, but the description goes further by stating 'There is no undo' and emphasizing the permanence of the deletion. It also warns that the returned copy is the only record, adding critical behavioral context beyond the structured hints. No contradiction with annotations; the description reinforces and enriches them.

Agents need to know what a tool does to the 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 concise and front-loaded with the core purpose. It uses a short second paragraph to convey essential warnings and alternatives without fluff. Every sentence adds value, and the structure makes it easy for an agent to quickly grasp the tool's intent and usage.

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

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

Given the presence of an output schema (mentioned in signals), the description need not enumerate return values, but it does highlight the returned copy of the deleted rule as important. It covers purpose, usage guidance, and irreversible consequences. The description is complete for an agent to invoke the tool correctly, including the caution about disabling 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 description coverage is 100%, with both rule_id and confirm_comment already fully documented (e.g., rule_id is 'The rule id from list_firewall_rules, e.g. *7'). The tool description does not add any extra parameter semantics beyond the schema, so the baseline of 3 is appropriate—the schema carries the parameter explanation.

Input schemas describe structure but not intent. Descriptions should explain 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 clear verb and resource: 'Delete a firewall rule permanently.' It also distinguishes the action from the sibling set_firewall_rule_enabled by explicitly naming that alternative. This makes the tool's purpose unambiguous and differentiates it from a related operation.

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

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

The description provides explicit usage guidance by stating that disabling the rule is 'almost always the better first move,' which tells the agent when to prefer set_firewall_rule_enabled over this tool. It also advises that the returned copy is the only record, implying the agent should capture it. This is clear, actionable guidance for when to use the tool.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds 'permanently' and the fact that the removed rule is returned, which is extra context beyond the annotations. It does not mention error handling (e.g., behavior if rule_id not found), but the annotations already set the expectation of destruction.

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

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

The description is a single, front-loaded sentence that states the action, scope, permanence, and return value. There is no wasted text, and the key information is immediately accessible.

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

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

With an output schema present, the description need not explain the return structure. The description covers the action, permanence, and what is returned. Combined with annotations that declare destructive and idempotent behavior, the agent has all necessary information to call the tool correctly.

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

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

The schema has a single parameter 'rule_id' with 0% description coverage. The description does not explicitly explain what rule_id is, but the tool name and purpose make it obvious that it identifies the rule to delete. The description adds minimal value beyond the schema, but the parameter is trivial enough that this is acceptable.

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

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

The description states a specific verb ('Delete') and resource ('NAT rule'), and adds the permanence qualifier ('permanently') and the return value ('Returns the rule that was removed'). This clearly distinguishes it from siblings like add_nat_rule or set_nat_rule_enabled, making the tool's purpose 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?

The description implies the use case (deleting a NAT rule) but does not explicitly state when to choose this tool over alternatives, such as using set_nat_rule_enabled to disable a rule instead of deleting it. No exclusions or alternatives are mentioned, leaving the selection logic 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?

The description restates the read-only and idempotent behavior already declared by the annotations, but adds little new behavioral context beyond that. The 'escape hatch' framing is useful positioning, though not a behavioral disclosure, and there is no contradiction with the annotations.

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

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

Two concise sentences front-load the core purpose and safety constraint. Every sentence earns its place; the escape-hatch guidance is included without unnecessary 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?

With one well-documented parameter, an output schema present, and read-only/idempotent hints in annotations, the description provides enough context for correct invocation. It covers what the tool does, when to use it, and its safety profile.

Complex tools with many parameters or behaviors need more documentation. 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 already fully documents the 'path' parameter with a clear description and examples at 100% coverage. The description adds no new parameter-level detail, but given the baseline for high schema coverage is 3, this is adequate.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Read'/'lists items') and a clear resource ('any RouterOS configuration path'). It also positions itself as the generic escape hatch for paths without a dedicated tool, which helps distinguish it from the many sibling tools.

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

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

The description explicitly states when to use this tool: for anything without a dedicated tool. It also draws a clear boundary by stating it is read-only and cannot modify the device, so the agent knows not to select it for configuration changes.

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

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

The annotations already carry idempotent and destructive hints; the description adds that the rule's position is preserved and that disabling is reversible, which is useful context beyond the schema. It does not fully explain what the destructive hint refers to in terms of live traffic impact, so it is not a perfect 5, but it does not contradict the annotations.

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

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

Two short sentences front-load the action and then add the most important usage guidance. There is no repetition of the schema or filler content.

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

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

For a two-parameter toggle tool with annotations, an output schema, and a rule_id description in the schema, this is complete enough to invoke safely. The description provides the additional context (ordering, reversibility) that the structured fields do not.

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

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

The schema already documents rule_id with a source and example, and the description clarifies the effect of the boolean enabled field: to toggle one rule on or off. This compensates for the missing enabled description and gives enough meaning to call the tool correctly.

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

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

The description opens with 'Enable or disable one firewall rule, leaving its position intact,' which names the specific operation, the target resource, and a distinguishing constraint. This clearly separates it from remove_firewall_rule, move_firewall_rule, and update_firewall_rule.

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

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

It explicitly tells the agent when to use this tool: when testing whether a rule is responsible for something, disabling is the reversible option and should be preferred over removing the rule. This gives a direct decision rule and names the main alternative (removal).

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?

Beyond the destructiveHint annotation, the description discloses a specific and critical behavioral consequence: disabling the interface used to reach the router will cut the connection and cannot be undone remotely. This is valuable, concrete context that annotations alone do not provide.

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

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

The description is extremely efficient: one sentence states the purpose, and a second sentence delivers the critical warning. There is no filler, repetition, or unnecessary detail.

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

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

Given the low complexity, output schema, and annotations, the description covers the essential behavioral risk. It could be slightly more complete by explicitly stating the true/false mapping and how to obtain the interface_id, but the schema and warning together make the tool safely usable.

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

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

Schema coverage is only 50%, and the enabled parameter is otherwise undocumented, but the description's "up or down" gives it meaningful semantic context. The interface_id parameter is already well described in the schema with its source and example, so the description compensates for the main gap.

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

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

The description states a specific verb and resource: "Bring an interface up or down." This directly and unambiguously identifies the operation and distinguishes it from sibling tools like list_interfaces or set_firewall_rule_enabled.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the tool is used by saying it toggles interface state, but it does not explicitly compare with alternatives or state when not to use it. The warning about cutting the management connection provides important context, and the schema points to list_interfaces, but the description itself gives no explicit usage guidance.

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

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

The description adds no behavioral detail beyond what the annotations already provide. idempotentHint and destructiveHint are present, but the text does not explain consequences, such as whether disabling a rule affects active connections or whether the rule persists while disabled. It does not contradict the annotations, but it also does not add transparency.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the action and the target resource.

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

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

This is minimally viable for a two-parameter toggle with an output schema and annotations: an agent can understand the core action. However, it lacks parameter provenance guidance, e.g., using list_nat_rules to find rule IDs, and does not address the destructiveHint implications that would help an agent use the tool carefully.

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

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

Schema description coverage is 0%, and the description does not explicitly explain rule_id or the enabled boolean. The phrase 'Enable or disable one NAT rule' implies the relationship, but there is no guidance on how to obtain a rule_id or the meaning of the enabled values beyond inference.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Enable or disable' + 'one NAT rule') and the singular scope clarifies that it operates on a single rule. It is immediately distinguishable from siblings like set_firewall_rule_enabled and set_interface_enabled because it explicitly targets NAT rules.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 about when to use this tool versus alternatives such as list_nat_rules, add_nat_rule, or remove_nat_rule. No prerequisites, exclusions, or context is given; the resource name only weakly implies the intended scenario.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description is not responsible for flagging safety. It usefully enumerates the reported fields, adding value beyond annotations, but it does not communicate behavior like whether the data is a snapshot or how uptime is expressed. This is acceptable given the structured 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?

A single well-structured sentence enumerates all returned data without filler. It is front-loaded with the identity attribute and reads naturally for an agent parsing the tool quickly.

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

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

For a no-parameter, read-only system information tool with an output schema, the description is fully sufficient. An agent knows what information will be returned and can safely invoke it. No additional guidance is necessary.

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

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

There are zero parameters, so the description has no parameter documentation burden. The baseline of 4 applies here; there is nothing additional needed.

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

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

The description names the specific subject—the device itself—and the concrete data delivered: identity, RouterOS version, model, uptime, CPU, and memory. This clearly distinguishes it from sibling tools that target firewalls, routes, or interfaces.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context is clear: use this when you need device-level system identity and resource state, rather than resource-specific lists like interfaces or firewall rules. It does not explicitly name alternatives or when-not-to-use, but the broad system scope is sufficiently self-evident for a zero-parameter tool.

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

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

Annotations already carry idempotentHint=true and destructiveHint=true. The description adds valuable behavioral context beyond that: only passed arguments are modified, omitted ones are left alone, and the tool returns the rule as it stands afterward. No contradiction with annotations.

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

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

The description is short, front-loaded with the core action, and every sentence earns its place. It states what it does, the critical partial-update behavior, and the return value with zero wasted words.

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

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

Given the output schema exists, the annotations cover destructive/idempotent hints, and the schema's rule_id description points to list_firewall_rules, the description supplies the remaining essential behavior: partial updates and return value. It is sufficient for an agent to invoke the tool correctly, though it could optionally mention value constraints for fields like chain or action.

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

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

With schema description coverage at only 6%, the description carries a heavy burden. It adds the crucial semantic that omitted parameters are not modified, which clarifies the default-null schema fields. However, it does not explain any individual parameter values or constraints, leaving most of the 18 parameters self-documented only by name.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Change fields on an existing firewall rule.' This clearly distinguishes it from add_firewall_rule (create), remove_firewall_rule (delete), and list/get_firewall_rule (read). The plural 'fields' also separates it from the narrow set_firewall_rule_enabled 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?

The description provides clear context for use: modifying an existing rule by updating only the fields you pass. It does not explicitly name alternatives or exclusions, but the purpose is unambiguous. The lack of explicit sibling routing prevents a 5.

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