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 operation (listing sessions) but does not explicitly state whether it is safe or has side effects. The behavioral disclosure is adequate but not thorough.

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 immediately conveys the tool's purpose and key details. Every word serves a purpose with no 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?

Despite no output schema, the description briefly explains the returned information (via, address, time) and the security audit context. For a simple tool with no parameters, it provides sufficient context for an agent to understand its use.

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

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

The tool has no parameters and schema coverage is 100%. The description adds value by specifying the return fields (via, address, time), though it doesn't need to explain parameters. The semantics are clear from the description 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 tool lists active login sessions with details (via, address, time) and indicates a security audit purpose. It distinguishes itself from similar sibling tools like hotspot_active or ppp_active through the context of router user sessions, though not explicitly contrasted.

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 mentions 'audit keamanan' (security audit) implying a usage context, but provides no explicit guidance on when to use this tool versus alternatives like ppp_active or when not to use it. No exclusions or alternative suggestions are given.

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

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

With no annotations provided, the description carries the full burden. It discloses the timeout behavior and permanent default, and the environment variable requirement. However, it does not mention idempotency, error handling, or return values, leaving gaps in behavioral understanding.

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 well-structured with a brief header, a use case sentence, and a clear parameter list. It is reasonably concise, though the 'Args:' section could be slightly tighter. Every sentence adds value with no 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 low complexity of the tool, the description covers the core action adequately. However, without an output schema, it omits any explanation of return values or error conditions, which is a notable gap for a write 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 coverage is 0%, so the description must compensate. It provides examples and explanations for all four parameters (address, address_list, comment, timeout), including format hints and default values. This adds significant meaning beyond the schema structure.

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 IP/subnet to a firewall address-list') and specifies the resource ('address-list'). It includes a use case differentiation ('suitable for mass blocking/allowing'), distinguishing it from sibling tools like 'remove_address_list_entry' and individual rule tools like 'add_firewall_drop'.

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 specifies a prerequisite ('BUTUH MIKROCLAW_ALLOW_WRITE=true') and suggests when to use it ('for mass blocking/allowing'). However, it does not provide explicit exclusions or alternatives, leaving the agent to infer when not to use this 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?

No annotations are provided, so the description bears full responsibility. It states the required macro for write permission and basic parameters but does not disclose important behavioral traits like duplicate handling, overwrite behavior, or error conditions. This is insufficient for a mutation tool.

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

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

The description is concise with only four lines including examples. It is well-structured with clear parameter descriptions. However, the use of Indonesian may reduce clarity for an English-speaking AI agent, but it is still 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 has 3 parameters, no output schema, and no annotations, the description adequately covers parameter usage. However, it lacks information about expected outcomes, return values, or side effects, which is needed for a write operation in a networking context.

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

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

Despite 0% schema description coverage, the description adds meaningful examples for each parameter (e.g., 'name: 'nas.lan'', 'address: '192.168.88.10'', 'ttl: '1d', '1h''). This provides useful context beyond the schema's property names and defaults, especially for the ttl format.

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

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

The description explicitly states the function: 'Add static DNS entry (A record: name -> address)'. It clearly identifies the resource and action, distinguishing it from sibling tools like dns_static (list) and set_dns_servers.

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 only mentions a required macro condition ('BUTUH MIKROCLAW_ALLOW_WRITE=true') but provides no guidance on when to use this tool versus alternatives (e.g., add_static_dhcp_lease for different purposes). It lacks explicit when-not-to-use or alternative suggestions.

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 cover behavioral traits. It only states that the tool adds a rule and requires write permission, but lacks details on potential side effects (e.g., rule insertion order, duplication, or impact on existing traffic). This is insufficient for a write operation.

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

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

The description is short and front-loaded with the action. However, mixing Indonesian and English may slightly reduce clarity. Otherwise, it is concise and to the point.

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

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

Given 3 simple parameters, no output schema, and no annotations, the description covers the essential purpose and parameter defaults. However, it lacks behavioral completeness (e.g., rule ordering, error conditions). Adequate but not comprehensive.

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 add meaning to parameters. It explains src_address with an example, and provides defaults for chain and comment. This adds significant value beyond the schema's bare 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?

The description clearly states that the tool adds a firewall rule to DROP traffic from a specified src_address. This specific verb and resource distinguish it from sibling tools like delete_firewall_rule 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 mentions a prerequisite: 'BUTUH ALLOW_WRITE' (needs write permission), which guides usage. It does not explicitly state when not to use this tool versus alternatives, but the context of adding a drop rule is well-defined and no sibling tool performs the same function.

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 provided. Description does not disclose side effects (e.g., overwriting behavior), error conditions (e.g., duplicate username), or required permissions beyond the environment variable. For a write operation, this is insufficient.

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?

Description is short and front-loaded with purpose and prerequisite. Arg list is clear. However, could be more concise by not repeating arg descriptions already implied by parameter names.

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

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

No output schema or annotations. Description covers basic parameters but lacks information about return values, error handling, or behavior on duplicate user. Adequate for simple create but not 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 description coverage is 0%, but description adds meaningful context for each parameter: 'username hotspot', 'password opsional', 'nama user-profile hotspot', 'catatan'. This compensates for missing schema descriptions.

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?

Description clearly states 'Tambah akun user hotspot' (Add hotspot user account) and lists arguments. It distinguishes from sibling tools like hotspot_users (list) and hotspot_active (sessions). However, it could be more precise about the exact resource/modification.

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?

Mentions prerequisite 'BUTUH MIKROCLAW_ALLOW_WRITE=true' but does not specify when to use this tool vs alternatives like hotspot_users or other add tools. Usage is implied but not 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?

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states the action (add) and the prerequisite, but omits consequences such as whether the operation is idempotent, what happens to existing addresses, or error conditions. This is insufficient for a write operation.

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

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

The description is extremely concise: two short sentences plus a list of arguments with examples. Every sentence adds value, and the key purpose is front-loaded. No wasted words.

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

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

For a relatively simple add operation, the description covers the basic parameters and prerequisite. However, it lacks details on idempotency, error handling, and whether the address can be added if one already exists. With no output schema, some behavioral context would be helpful.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear examples for address ('2001:db8::1/64') and interface ('bridge1'), and explains the comment parameter as 'catatan' (note). This adds significant meaning beyond the schema's bare titles.

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 'Pasang alamat IPv6 ke sebuah interface' (Add IPv6 address to an interface), which is a specific verb and resource. Although tools like assign_ip_address exist for IPv4, this tool is distinct for IPv6, and the description makes that clear.

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 includes a prerequisite (MIKROCLAW_ALLOW_WRITE=true) which helps with usage, but it does not explicitly state when to use this tool versus alternatives like assign_ip_address or other add tools. No explicit when-not-to-use 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?

As no annotations are provided, the description must convey behavioral traits. It describes the additive nature of creating a rule and notes the default comment. Yet it lacks details on error handling, idempotency, or potential 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 description is well-structured: purpose, prerequisite, examples, then parameter list. It is front-loaded and efficient, though slightly verbose with example 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?

The description covers all parameters and common use cases, but it does not describe return values or error conditions. Given the tool's complexity (11 params, no output schema), it is nearly complete but lacks operational 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?

With 0% schema coverage, the description fully compensates by explaining all parameters, listing optional ones, and providing usage examples for chain, action, and others. This adds significant 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 clearly states the tool adds NAT rules (port-forward/masquerade) and provides concrete examples. It distinguishes from siblings like add_firewall_drop by focusing on NAT operations.

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 includes a prerequisite (MIKROCLAW_ALLOW_WRITE=true) and examples for port-forward and masquerade, showing when each is used. However, it does not explicitly mention when not to use this tool or suggest 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. It mentions a configuration requirement but does not disclose behavioral traits such as whether the operation is reversible, what side effects occur, or authentication needs beyond the environment variable.

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

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

The description is short and front-loaded with the purpose in Indonesian, followed by the requirement and argument list. Every sentence is necessary, though the mix of languages (Indonesian and English) slightly reduces clarity for non-Indonesian agents.

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 creation tool with 4 parameters and no output schema, the description covers all inputs and prerequisites. However, it lacks details on what the tool returns, error handling, or confirmation of success, making it adequate but not comprehensive.

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%, but the description explains each parameter: name (username), password, service (with example values), and profile (with default). This adds significant meaning beyond the schema, though it could include constraints like password format or service enum.

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 PPP account (PPPoE/VPN) and lists its arguments. It is specific about the resource but does not differentiate from sibling tools like add_hotspot_user or add_static_dhcp_lease, which have similar 'add' verbs.

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 a prerequisite (MIKROCLAW_ALLOW_WRITE=true) but gives no explicit guidance on when to use this tool versus alternatives, nor when not to use it. The usage context 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?

The description states that the tool lists contents, implying a read operation, but does not explicitly declare its read-only nature, required permissions, or any side effects. With no annotations, the description could be more transparent about behavioral traits.

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 sentence with no unnecessary words. It is concise and front-loaded, conveying the essential purpose efficiently.

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

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

Given no output schema, parameters, or annotations, the description provides basic context but lacks details on output format (e.g., whether it returns list names, entries, or both). It also does not mention read-only behavior, which would aid completeness.

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

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

There are zero parameters, and the schema coverage is 100%, so the description does not need to add parameter meaning. The baseline score of 4 is appropriate as the description adds no confusion.

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 indicates that the tool lists the contents of all firewall address-lists, which are IP groups used in firewall rules. The verb 'Isi' (contents) clarifies it's a listing operation, distinguishing it from add/remove sibling tools, though it could specify whether it returns list names, entries, or both.

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

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

No guidance is provided on when to use this tool versus alternatives like add_address_list_entry or remove_address_list_entry. The description lacks context for appropriate usage scenarios.

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 bears full burden. It indicates a write operation and a requirement flag, but does not disclose return values, error handling, idempotency, or side effects such as whether existing queues can be overwritten.

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: one sentence for purpose, one line for requirement, and a structured parameter list with examples. Every sentence adds value with no redundancy, and the purpose is front-loaded.

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

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

For a simple add tool with 3 parameters and no output schema, the description covers the essential purpose, requirement, and parameter formats. However, it does not describe the return value, postconditions (e.g., the queue will appear in simple_queues), or potential errors, which would improve completeness.

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

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

Schema coverage is 0%, so the description must compensate. It provides concrete examples for all three parameters (e.g., name: 'limit-tamu', target: '192.168.88.50/32', max_limit: '5M/10M'), adding meaning beyond the schema's type-only definitions.

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

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

The description clearly states the verb 'Tambah' (add) and resource 'simple queue' with purpose 'membatasi bandwidth target' (limit bandwidth target). It distinguishes itself from sibling tools like 'simple_queues' (list) and 'queue_tree' by specifying 'simple queue', but does not explicitly differentiate from alternatives.

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

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

The description includes the prerequisite MIKROCLAW_ALLOW_WRITE=true and provides example parameter formats. However, it does not specify when to use this tool versus alternatives like queue_tree, nor does it mention 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It declares that this is a write operation requiring a specific environment variable, but it does not disclose potential side effects (e.g., overwriting existing leases), error conditions, or the outcome of the operation. The description is adequate but not thorough.

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, with the purpose stated first, followed by a clear requirement and parameter list. Every sentence adds value without redundancy. It is well-structured and easy to parse.

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

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

Given the tool's simplicity (4 parameters, no output schema), the description covers the essential aspects: purpose, required env variable, parameter explanations. However, it lacks information about the response or any post-creation state, which could be useful for an agent to confirm success.

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

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

The input schema has no descriptions for parameters (0% coverage), so the description must compensate. It does so effectively by providing examples for each parameter and indicating which are required and optional. It adds meaning beyond the schema, though it could detail format constraints for MAC addresses.

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

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

The description clearly states the tool's purpose: pinning a static IP to a MAC address (static DHCP lease). It uses specific verbs and resources, but does not explicitly differentiate from sibling tools that also perform write operations, though the context of 'static DHCP lease' is unique among the listed siblings.

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

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

The description includes a prerequisite ('BUTUH MIKROCLAW_ALLOW_WRITE=true'), which provides some guidance. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention when not to use it. The usage context is implied but not fully elaborated.

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 full burden. It discloses the write permission requirement but does not mention potential side effects (e.g., duplicate routes, persistence, error handling) or whether the operation is destructive. This is insufficient for a write operation.

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

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

The description is extremely concise with a two-line header followed by bullet-style parameter explanations. Every sentence serves a purpose, and the structure is front-loaded with the core purpose and requirement.

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 description covers parameter usage well but lacks information about return values, immediate effects, or error responses. For a simple add operation, this is acceptable but not fully complete given no output schema.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining all four parameters with examples and context (e.g., 'mis. 10.20.0.0/24' for dst_address). This adds significant meaning beyond the schema's type definitions.

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 explicitly states 'Tambah route statis' (Add static route) and provides parameter examples, making the purpose clear. However, it does not differentiate from sibling tools beyond the name itself, which is unique but not elaborated.

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 includes a required environment variable 'BUTUH MIKROCLAW_ALLOW_WRITE=true', which is a usage condition. However, it does not specify when to use this tool over alternatives or provide scenarios where it 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?

With no annotations provided, the description only mentions the need for write permission, indicating a destructive action. However, it does not disclose what happens on success, conflict, or error, nor any side effects beyond the write requirement.

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

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

The description is short, front-loaded with the main action and requirement, and lists parameters clearly in separate lines. Every sentence contributes value without 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?

For a tool with 5 parameters (3 required) and no output schema or annotations, the description covers parameters and a write requirement but lacks return value information, error scenarios, or behavior on duplicate entries. It is adequate for basic use but not fully comprehensive.

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%, but the description adds meaningful context to each parameter, including example values (e.g., 'wg0', '10.10.0.2/32') and clarifies that endpoint fields are optional. This compensates well for the lack of schema descriptions.

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 'Add WireGuard peer to an interface' in Indonesian, with a precise action on a specific resource. It distinguishes from sibling tools like wireguard_peers (which lists peers) and wireguard_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 description notes a required environment variable (MIKROCLAW_ALLOW_WRITE=true) as a prerequisite but offers no guidance on when to use or avoid this tool versus alternatives. Usage context is implied but 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?

No annotations are provided, so the description carries full burden. It only states the content (IP-MAC mapping visible to router) but does not disclose any behavioral traits like read-only nature, output format, or potential delays. The description is too minimal for a no-annotation case.

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 sentence with no wasted words. It is appropriately sized for a simple listing tool.

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

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

Given no output schema and no annotations, the description fails to provide complete context. It does not describe return format, pagination, or how this tool fits among siblings like 'neighbors' or 'routing_table'. For a tool with zero complexity, it is minimally adequate but incomplete.

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

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

There are no parameters, and schema coverage is 100%. According to rules, baseline is 4 for zero-parameter tools. The description adds no extra param info but is not required to.

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 that the tool retrieves the ARP table, which maps IP to MAC addresses visible to the router. The verb 'tabel' (table) implies listing, and the resource is specific (ARP table). It distinguishes from siblings like 'routing_table' or 'neighbors' by focusing on IP-MAC mapping.

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

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

No guidance on when to use this tool versus alternatives such as 'neighbors' or 'routing_table'. The description does not provide context for selection 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 provided, so description carries full burden. It discloses it is a write operation and needs a permission flag, but lacks details on error handling, overwrite behavior, or validation of inputs. This is insufficient for a configuration-changing 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?

Very concise: one line for purpose and condition, followed by a bulleted list of parameters. No unnecessary 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?

Missing important context for a write operation: no mention of return values, error scenarios, or safety warnings. With no output schema and no annotations, the description is incomplete for practical 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 has 0% description coverage, but the description adds examples for each parameter: address format ('192.168.50.1/24'), interface names ('bridge1' or 'ether2'), and comment as 'catatan'. This adds meaningful context beyond the schema.

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

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

Clearly states it assigns an IP address (CIDR) to an interface, with a specific prerequisite ('BUTUH MIKROCLAW_ALLOW_WRITE=true'). The tool name reinforces the purpose, and it is distinct from siblings like 'add_ipv6_address'.

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?

Explicitly requires the environment variable MIKROCLAW_ALLOW_WRITE=true, indicating when the tool can be used. However, it does not mention when not to use it or compare to alternative 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?

No annotations are provided, so the description must carry the full burden of disclosing behavioral traits. It does not mention that the tool is read-only, requires authentication, or any other side effects. This is a significant gap.

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

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

The description is a single sentence, which is concise but lacks detail. It is not verbose, but it could be improved by adding more context without being overly long.

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 absence of an output schema and annotations, the description should elaborate on the return format or behavior. It only mentions 'status/peer' but does not describe what data is returned, making it incomplete for an agent to fully understand the tool's output.

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

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

The input schema has zero parameters, so the description cannot add meaning beyond what the schema provides. With no parameters, the baseline is 4, and the description is adequate for this simple tool.

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 it is about BGP sessions with status/peer information for RouterOS v7. It clearly identifies the resource and implied action (listing/viewing), but it is brief and does not differentiate from sibling tools like ospf_neighbors.

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

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

No guidance is provided on when to use this tool versus alternatives such as active_sessions or ospf_neighbors. The description lacks any context about appropriate use cases.

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

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

With no annotations, the description carries full burden for behavioral traits. It indicates a read operation (listing learned MACs) but doesn't disclose potential side effects, performance considerations, or data freshness. The description is minimally adequate but lacks depth.

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 sentence, highly concise. However, it is in Indonesian, which may hinder readability for non-Indonesian speakers. The structure is simple and front-loaded, but could benefit from an English equivalent or title.

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

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

For a simple parameterless tool, the description gives the general idea (retrieving bridge host MAC table). However, it doesn't specify the exact output fields or structure, which would help an agent interpret the result. It is adequate but not thorough.

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 no parameters, and schema coverage is 100% (trivially). The description confirms no input is needed, which is useful. It adds no extra parameter information because none exists, but it correctly implies the tool is a simple list operation.

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 provides a table of host bridge entries (MAC addresses learned per bridge port). This is a specific verb-resource pairing and distinguishes it from siblings like bridge_ports, which likely show port configurations rather than learned MACs.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. An agent would have no context about when to choose bridge_hosts over bridge_ports or other network inspection tools.

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

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

With no annotations, the description must fully disclose behavior. It only states the mapping function but does not indicate whether the tool is read-only, what the output format is, or any side effects. This is minimal transparency for a tool with zero annotations.

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

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

The description is a single concise sentence that earns its place. It is front-loaded with the key action and resource, with no unnecessary 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 lack of annotations and output schema, the description is too minimal. It does not explain what the tool returns, how to interpret the mapping, or any usage context. A more complete description would mention that it lists all interfaces and their bridge associations.

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 no parameters, so schema coverage is 100%. The description adds no parameter info, but none is needed. Baseline for zero parameters is 4, and the description does not detract.

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

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

The description 'Pemetaan port ke bridge (interface mana ikut bridge mana)' clearly states the tool maps ports to bridges. It is specific about the resource (bridge ports) and the action (mapping). However, it does not explicitly differentiate from sibling tools like 'bridge_hosts' or 'ethernet_ports', though the focus on bridge membership is distinct.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., 'bridge_hosts' for hosts on bridges, 'vlans' for VLAN assignments). The description does not specify context or prerequisites.

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 fully disclose behavioral traits. It mentions coverage of 'auto legacy atau wifiwave2' but does not describe whether the operation is read-only, any side effects, or permissions needed. The minimal description fails to compensate for the lack of annotations.

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

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

The description is a single, short sentence that conveys the core purpose without waste. However, it could be slightly more informative (e.g., clarifying the output) without becoming verbose. Still, it is appropriately compact.

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 simplicity (no parameters, no output schema, no annotations), the description is minimal. It omits details about the output format, what 'registrations' includes, and any behavioral notes. More context would improve completeness without overwhelming the agent.

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

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

The input schema has zero parameters and 100% coverage. With no parameters to document, the description adds no parameter information, but this is acceptable as baseline given the schema handles all. The description does not need to elaborate on parameters.

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

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

The description states 'Klien yang terhubung lewat CAPsMAN' which clearly indicates the tool lists clients connected via CAPsMAN. The mention of 'Auto legacy atau wifiwave2' clarifies the scope, though it does not explicitly differentiate from sibling tools like capsman_remote_caps or wifi_registrations.

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

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

No guidance on when to use this tool versus alternatives. The description lacks any conditional, prerequisites, or contrasts with sibling tools, leaving the agent to infer usage context on its own.

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 provided. Description indicates a read operation (list) but does not disclose output structure, pagination, or potential side effects. For a parameterless list tool, it is minimally adequate but lacking detail.

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

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

Extremely concise: two short sentences, no redundant information. Every word earns its place.

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

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

For a simple list operation with no parameters and no output schema, the description is mostly complete. Could mention distinction from capsman_registrations, but adequate.

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?

No parameters exist, so schema coverage is 100%. The description adds no parameter info, but baseline is 4 for zero parameters.

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

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

Description clearly states it lists CAP (AP) managed by CAPsMAN, and indicates auto-detection of legacy vs wifiwave2. The verb 'Daftar' (list) is specific, but does not differentiate from sibling capsman_registrations.

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

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

No explicit guidance on when to use this tool versus alternatives like capsman_registrations. The mention of auto-detection implies context but lacks clear when-to-use or when-not-to-use.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It indicates a read-only listing operation and mentions validity period, but does not specify whether it returns all certificates, filtering, or any other side effects. Missing details like if it requires authentication or if it's destructive.

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

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

Single sentence, efficient, and front-loaded. No wasted words; every piece of information is valuable.

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 0 parameters and no output schema, the description adequately states what the tool lists (certificates) and what detail (validity). However, it could be more explicit about scope (all certificates) and response shape.

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

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

The tool has 0 parameters, so the description does not need to add parameter info. The phrase 'masa berlaku (audit kedaluwarsa)' adds context about the data returned, which goes beyond the empty schema.

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

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

The description clearly states the tool lists certificates with validity periods for expiration audit. It uses specific vocabulary ('Daftar sertifikat', 'masa berlaku') and distinguishes from siblings that list other resources.

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

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

No explicit guidance on when to use this tool versus alternatives like other list tools. The purpose is implied, but no exclusions or prerequisites are mentioned.

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

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

No annotations are provided, so the description carries full burden. It discloses that the operation is non-destructive and that it contacts a remote server. However, it does not mention potential network requirements, latency, or caching behavior. The behavioral insight is adequate but minimal.

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 two concise sentences with no unnecessary words. It front-loads the purpose and immediately clarifies the read-only nature. Every sentence earns its place.

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

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

Given the tool has no parameters and no output schema, the description covers the essential aspects: purpose, non-destructive behavior, and return value (installed and latest versions). It is complete enough for a simple check operation, though it could hint at the output format more precisely.

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 schema coverage is 100%. The description adds no parameter details because none are needed. For zero-parameter tools, the baseline is 4, and the description properly explains the channel context ('current channel').

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 checks for RouterOS updates from the current channel by contacting MikroTik servers. It uses a specific verb ('check') and resource ('updates'), and no sibling tool appears to duplicate this functionality, so it is well-distinguished.

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 mentions that the tool does not change configuration, implying it is a read-only operation. However, it does not provide explicit guidance on when to use it (e.g., before upgrading) or when alternatives like system_packages might be more appropriate. The usage context is implied but not stated.

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

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

No annotations provided. The description discloses a behavioral requirement (write permission) and implies file creation, but does not detail overwrite behavior, error handling, or whether the tool is destructive.

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

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

Extremely concise with two sentences and a parameter list. No wasted words; the main action and prerequisite are front-loaded.

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

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

For a simple one-parameter tool with no output schema, the description covers the basic purpose, permission requirement, and parameter format. However, it lacks information about return value, success/failure feedback, or file overwrite 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?

The description explains the parameter 'name' as 'nama file backup (tanpa ekstensi)' (backup file name without extension), adding semantic value beyond the schema. Schema coverage is 0%, so description compensates well.

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

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

Clearly states the action 'Buat file backup konfigurasi' (create configuration backup) and the resource (.backup file in router storage). However, it does not explicitly distinguish from sibling tools, but no direct backup alternative exists.

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 a prerequisite (MIKROCLAW_ALLOW_WRITE=true) indicating when the tool can be used, but lacks explicit guidance on when not to use or comparison to 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 provided, so description bears full burden. It discloses the write permission requirement but does not mention that deletion is irreversible, any potential side effects (e.g., if rule is referenced elsewhere), or what the response indicates. Adequate but could be more thorough.

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 sentences: purpose, requirement, and argument explanation. No fluff, every sentence adds value. Perfectly sized for the tool's simplicity.

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 delete-by-ID tool, the description covers operation, argument, and prerequisite. Lacks mention of irreversibility or error conditions, but given the simplicity, it is largely complete. Reference to sibling tool firewall_filter_rules provides necessary context.

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

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

The sole parameter rule_id has no schema description (0% coverage). The description compensates by specifying format ('*5'), that it's the '.id' value, and that it must be retrieved from firewall_filter_rules. This adds meaningful context beyond the raw schema.

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

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

The description clearly states the action: delete a single firewall filter rule by ID. It distinguishes from sibling tools like set_firewall_rule_enabled by specifying 'delete' and references the source of the ID (firewall_filter_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?

The description tells when to use the tool (when deleting a firewall rule) and provides a crucial prerequisite: obtain the rule ID from firewall_filter_rules first. It also mentions the required environment variable MIKROCLAW_ALLOW_WRITE=true, guiding the agent on correct usage.

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

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

Without any annotations, the description should disclose behavioral traits. It implies a read-only operation but does not explicitly state that no modifications are made, whether authentication is required, or how results are structured. The phrase 'per interface' is ambiguous without a parameter.

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. It is front-loaded with the key action word 'Status'. However, it mixes languages (Indonesian) which might reduce clarity for non-Indonesian speakers.

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 parameterless tool, the description is minimally sufficient. However, it does not explain the return format, what 'per interface' means without an interface filter, or any error conditions. More context would improve agent understanding.

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 no parameters, so the parameter semantics burden is low. The description adds the context 'per interface' beyond the empty schema, but it does not clarify how this is handled without a parameter. Baseline of 4 is appropriate given zero parameters and 100% schema coverage.

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

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

The description clearly indicates the tool retrieves the status of the DHCP client, specifically the WAN IP from ISP, per interface. It uses a specific verb ('Status') and resource ('DHCP client'), and the purpose is distinct from sibling tools like dhcp_leases or dhcp_servers.

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

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

No guidance is provided on when to use this tool versus alternatives such as dhcp_leases or list_interfaces. The description lacks information about prerequisites, when not to use it, or how it fits into a broader workflow.

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

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

No annotations are provided, so the description must carry the full burden. It states that the tool returns a list of DHCP leases, which is transparent enough for a simple read operation. However, it does not disclose if the list includes all leases or only active ones, or any other behavioral traits.

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 efficiently conveys the tool's purpose without any 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 no output schema and a simple list tool, the description is adequate but could be improved by hinting at the return structure or the scope of leases (e.g., current leases from the router's DHCP server).

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 no parameters, so schema description coverage is 100% by default. The description adds value by explaining what a DHCP lease is, going beyond the empty schema.

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

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

The description clearly states the tool lists DHCP leases and explains what that means ('klien yang dapat IP dari router'). However, it does not distinguish from related sibling tools like dhcp_servers or dhcp_networks, though the resource is clear.

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

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

No guidance on when to use this tool versus other DHCP-related sibling tools or similar listing tools. The description provides no context for selection decisions.

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 convey behavioral traits. It mentions 'configuration' but does not clarify if the tool performs read-only listing or modifications, leaving ambiguity about its 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 description is a single sentence, concise and front-loaded. However, it is in Indonesian, which may reduce clarity for non-Indonesian-speaking agents, but it remains 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?

With no output schema and no annotations, the description is the only context. It does not explain what operation the tool performs (e.g., is it a list or configuration command?), nor does it cover all potential DHCP network fields beyond the three mentioned.

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

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

The input schema has zero parameters, so there is nothing to explain. The description adds no parameter details, but the baseline for zero-parameter tools is 4, as no additional parameter insight is needed.

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

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

The description clearly states the tool deals with DHCP network configuration including gateway, DNS, and netmask. However, it does not differentiate from sibling tools like dhcp_servers or add_static_dhcp_lease, and it does not specify whether it lists or modifies configurations.

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

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

No guidance on when to use this tool versus alternatives. With related sibling tools (e.g., dhcp_servers, add_static_dhcp_lease), the description provides no context for selection.

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

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

No annotations are present, and the description does not disclose behavioral traits such as read-only nature, authentication requirements, or side effects. It only describes what it lists, leaving the agent uncertain about potential impacts.

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

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

The description is a single, well-structured sentence that immediately conveys the tool's purpose. No extraneous information, perfectly 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 simplicity (no params, no output schema), the description is adequate but lacks details about the return format or the structure of listed data. It does not fully enable an agent to understand the output without additional context.

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

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

The tool has zero parameters, and the schema coverage is 100% (empty). The description adds no parameter meaning because none exist. Baseline score of 3 is appropriate as the description is neither helpful nor harmful.

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 it lists DHCP servers with interface and address pools. It uses a specific verb ("Daftar" meaning list) and resource, but does not explicitly differentiate from sibling tools like dhcp_leases or dhcp_networks, though the scope is implied.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or when to choose dhcp_servers over similar tools like dhcp_leases.

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 must fully communicate behavioral traits. It only states the tool shows cached entries, but does not disclose whether it is a read-only operation, any side effects, rate limits, or that it requires no parameters. This leaves critical behavioral uncertainty.

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 immediately communicates the tool's purpose without any extraneous text. It is optimally front-loaded and efficient.

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

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

For a parameterless tool with no output schema, the description is adequate: it identifies the exact resource and function. However, it could benefit from a note on the output format or that the cache is dynamic, but overall it is sufficiently complete for a simple read 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?

The input schema has zero parameters with 100% schema description coverage. Per guidelines, baseline is 4. The description adds no parameter info since none exist, so no additional value is needed.

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

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

The description clearly states the tool displays the cached DNS entries of the router resolver. The verb 'Isi' (content) and resource 'cache DNS resolver' are specific, and the parenthetical clarifies it's the cached entries. This distinguishes it from siblings like dns_static (static entries) and dns_settings (settings).

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 lacks any guidance on when to use this tool versus alternatives. It does not mention when not to use it, prerequisites, or contrast with sibling tools. Agents must infer from the tool's 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?

No annotations are provided, so the description must disclose behavioral traits. It does not state whether the tool is read-only, requires authentication, or has side effects. The term 'Konfigurasi' could imply mutation, but no parameters suggest a read operation—this ambiguity is problematic.

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 (short phrase), but it lacks sentence structure and is only in Indonesian. It could be organized into a clearer statement with a verb.

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

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

With no output schema, the description should explain return values or behavior. It lists three configuration aspects but does not describe the output format (e.g., what fields are returned, type of values). The tool is simple but incomplete for an agent to understand what it will receive.

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?

Input schema has zero parameters, so schema coverage is 100% trivially. The description adds value by listing the aspects of DNS configuration (upstream server, cache, allow-remote-requests), hinting at output content beyond the empty schema. Baseline for 0 params is 4 per guidelines.

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?

Description indicates the tool is about router DNS configuration covering upstream server, cache, and allow-remote-requests, but lacks a verb (get/set) and does not distinguish from sibling tools like dns_cache or set_dns_servers. The noun 'Konfigurasi' leaves ambiguity about whether it reads or modifies.

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

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

No guidance on when to use this tool versus alternatives. Among siblings, there are multiple DNS-related tools (e.g., set_dns_servers, dns_cache), but the description provides no context for selection.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It does not state whether the operation is read-only, destructive, or requires permissions, nor does it mention any 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 description is extremely concise (one phrase in Indonesian) with no wasted words. It front-loads the core purpose immediately.

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

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

Given zero parameters, no output schema, and no annotations, the description covers basic purpose but lacks details on output format, pagination, or error conditions. It is minimally adequate but not comprehensive.

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 no parameters in the input schema, so schema description coverage is 100%. The description does not add parameter meaning since none exist, making a baseline score of 4 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 clearly states the tool retrieves static DNS entries (A/CNAME/etc) served by the router. It implicitly distinguishes from sibling tools like add_dns_static (adds entries) and dns_cache (DNS cache), making 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?

No guidance on when to use this tool versus alternatives. Sibling tools exist (e.g., add_dns_static, dns_cache) but the description provides no context for selection 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 provided; description does not disclose any behavioral traits such as being read-only or having side effects. For a tool with zero annotations, the description should provide more context.

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

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

Description is concise, using one sentence to convey the key information. It is front-loaded but slightly under-specified.

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

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

No output schema, so description should provide more detail about return structure. It mentions specific attributes but not the full set, leaving gaps for an agent.

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

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

Tool has zero parameters, so description cannot add parameter-specific value. Baseline score of 4 is appropriate as there are no parameters 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?

Description clearly states the tool details Ethernet port information: link speed, auto-negotiation, and physical status. However, it could be more specific to differentiate from sibling tools like list_interfaces or bridge_ports.

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

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

No guidance on when to use this tool versus alternatives. Sibling tools include many network-related commands, but no context is provided for selecting this one.

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

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

No annotations provided, so description must fully disclose behavioral traits. It mentions the data fields (src/dst, protocol, state) but does not state whether the operation is read-only, safe, or has any side effects. The implicit assumption is that it is read-only, but not confirmed.

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

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

Extremely concise single sentence. No wasted words, front-loads core purpose and content. Ideal length for simple tool.

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

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

Given no output schema and zero parameters, the description could be considered minimally adequate. However, it does not explain the return format, pagination, or how it relates to sibling tools like 'active_sessions' or 'firewall_filter_rules'. Lacks completeness for a troubleshooting tool.

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

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

No parameters in input schema, baseline is 4. Description adds context by listing the data fields returned, which helps the agent understand what information the tool provides.

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?

Description clearly states it is for connection tracking, listing active connections with src/dst, protocol, and state, and for troubleshooting. This is specific and understandable, but it does not differentiate from sibling tools like 'active_sessions' or 'firewall_filter_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?

No explicit guidance on when or when not to use this tool. Merely states 'untuk troubleshooting' (for troubleshooting), but lacks context such as alternatives or prerequisites.

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 provided. The minimal description does not disclose behavioral traits such as read-only/read-write, authentication needs, or what the tool returns.

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

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

Very concise single phrase, but could be more informative by adding a verb or brief context.

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

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

For a tool with no parameters and no output schema, the description provides the essential context (chains) but omits what action the tool performs (e.g., listing rules). Adequate but could be more 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?

Input schema has 0 parameters, so description does not need to add parameter information. Baseline score of 4 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?

Description clearly indicates the tool deals with firewall filter rules and specifies the chains input/forward/output, distinguishing it from NAT or mangle rules. However, it lacks an explicit verb like 'list' or 'get'.

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

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

No guidance on when to use this tool versus sibling tools like firewall_nat_rules or firewall_mangle. The agent must infer from the chain mention.

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 lacks any behavioral disclosure. With no annotations, the agent has no information on whether this tool is read-only or destructive, what side effects exist, or authentication requirements. The vague term 'aturan' (rules) could imply listing or modification, but it's ambiguous.

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

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

The description is a single short sentence with no unnecessary words. It is appropriately concise for the limited information provided, though it could be slightly more informative without losing conciseness.

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

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

Given the lack of annotations, output schema, and parameters, the description is insufficient. It does not explain what the tool returns (e.g., a list of mangle rules), how it interacts with the firewall, or any usage examples. A tool with zero parameters likely performs a simple list operation, but this is not confirmed.

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 schema coverage is 100% (vacuous). The description adds no parameter information, but none is needed. Baseline score of 4 is appropriate given no parameters to describe.

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 tool as dealing with firewall mangle rules for marking connections/packets for QoS/policy routing. It uses a specific resource name and distinguishes from sibling tools like firewall_filter_rules and firewall_nat_rules, though it doesn't explicitly state the action (list/manage).

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

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

No guidance is provided on when to use this tool versus alternatives. There is no indication of prerequisites, context, or exclusion criteria, leaving the agent without direction on selecting this tool over sibling firewall tools.

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

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

With no annotations, the description should disclose behavioral traits. It only states 'NAT rules' without mentioning read-only nature, pagination, or any constraints. Minimal 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?

Extremely concise single sentence that front-loads the resource and types. Could be slightly more structured, but overall efficient with no 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?

For a simple listing tool with no parameters or output schema, the description is adequate but minimal. It does not explain output format or that it lists rules. Sibling tool context adds some completeness.

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

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

Input schema has zero parameters, so schema coverage is 100%. The description adds examples (masquerade, port forward) providing context beyond the schema. Baseline score 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 clearly states the tool provides NAT rules (srcnat/dstnat) with examples like masquerade and port forward. It is specific and distinguishes from sibling tools like firewall_filter_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?

No guidance on when to use this tool versus alternatives such as add_nat_rule or delete_firewall_rule. The description does not provide context 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, but the description trades transparency for a simple read operation. It does not specify whether authentication is required, if the list is real-time, or any side effects. It is adequate but minimal.

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 sentence with no unnecessary words. It is front-loaded and perfectly concise for the task.

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

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

Given the tool has no parameters, no output schema, and performs a simple listing of active users, the description is complete. No additional information is required.

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 schema coverage is 100% (empty properties). According to guidelines, baseline is 4 for no parameters. No further explanation needed.

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

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

The description clearly states it returns currently active hotspot users ('yang sedang login'). It distinguishes from sibling tools like 'hotspot_users' which likely list all users. The purpose is specific and 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?

No guidance on when to use this tool versus alternatives such as 'hotspot_users' or 'active_sessions'. There is no mention of context or prerequisites.

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 implies a read operation but does not explicitly state read-only, required permissions, or any side effects. With no annotations, the description should provide more behavioral context.

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

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

The description is a single sentence with no unnecessary words. It is concise and to the point.

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

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

Given no parameters and no output schema, the description covers the essential functionality. It could be more explicit about the return format, but it is adequate.

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?

Input schema has 0 parameters, so schema coverage is 100%. The description adds no parameter info, but baseline for 0 params is 4.

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 lists hotspot servers along with their interfaces and profiles, which is a specific verb+resource. Among siblings, there is no other hotspot_servers tool, so it distinguishes itself.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any context 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 provided, so description carries full burden. It only mentions listing accounts but does not disclose behavioral traits like read-only nature, authorization needs, or any side effects. Minimal transparency beyond purpose.

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

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

Single short sentence with no unnecessary words. Front-loaded and efficient.

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

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

For a parameterless list tool without output schema, description names the fields but doesn't specify return format (e.g., array of objects). Adequate but could be more 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?

With zero parameters and 100% schema coverage, description adds value by indicating the returned fields (name, profile, quota). Baseline for 0 params is 4, and description fulfills that.

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 it lists hotspot user accounts (verb 'daftar' meaning list) and specifies the included information: name, profile, quota. This distinguishes it from sibling tools like add_hotspot_user (create) and hotspot_active (active sessions).

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

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

The description provides no guidance on when to use this tool vs alternatives or exclusions. It only states the function without context.

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

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

No annotations provided. The description says 'real-time' and 'sampel' (sample) implying a single read, but lacks details on effects (likely read-only), duration, or safety. Adds basic context but insufficient for full 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?

Short description with an Args section, but the Args section repeats the schema without adding value. Could be more concise by integrating parameter info.

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

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

No output schema. The description mentions 'throughput real-time interface (rx/tx bit-per-detik)' indicating the return value, but does it return both rx and tx separately? Incomplete for a single-sample tool. Adequate but not fully complete.

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

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

The schema has 0% description coverage. The description gives an example 'mis. \'ether1\'' but doesn't explain format, constraints, or default values. Minimal added meaning beyond the schema.

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

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

The description clearly states the action 'Ambil satu sampel' (take one sample) and the resource 'throughput real-time interface (rx/tx bit-per-detik)'. It distinguishes from sibling tools like 'list_interfaces' which list interfaces but not traffic.

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

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

No guidance on when to use this tool versus alternatives like other monitoring tools. No mention of exclusions or context.

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

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

No annotations are provided, and the description does not disclose whether this tool is read-only, modifies state, or requires authentication. There is no behavioral context beyond the name and a general statement about remote access. For a tool with zero annotations, this is a significant gap.

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

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

The description is very concise (one short sentence) and front-loaded with the key terms. No wasted words, but it could be more structured (e.g., separating purpose from usage). The brevity is effective but leaves gaps in other dimensions.

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

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

Given the tool has no parameters and no output schema, the description should compensate by explaining what information the tool provides (e.g., current public IP, DDNS status). The current description only states the topic area, not the actual output or behavior. This is incomplete for an agent to determine if the tool answers a specific user query.

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 no parameters and the schema coverage is 100% (empty). The description does not add parameter-level detail but also doesn't need to. However, it fails to explain what the tool returns or how to interpret the output, which is necessary for a parameterless tool. A score of 3 reflects adequate but not excellent handling.

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 specifically states 'IP publik & DDNS MikroTik (/ip/cloud)' which clearly identifies the resource and its domain. The addition 'penting untuk remote access' gives context, though it doesn't fully disambiguate from sibling tools like dns_settings or ip_services. It's clear enough for an agent to understand the general 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 provides only a vague usage hint ('penting untuk remote access') but no explicit guidance on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or comparison to sibling tools like check_for_updates or system_identity which might also relate to network access.

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

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

No annotations are provided, so the description carries the full burden. It states this is a list operation, implying read-only behavior, but does not confirm non-destructive nature, permissions, or return format. For a simple list tool with no parameters, this is adequate but not rich.

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, complete sentence that efficiently conveys the tool's purpose. No filler or redundant information. Front-loaded with the key action and resource.

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

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

Given zero parameters, no output schema, and a straightforward list operation, the description sufficiently explains what the tool does. There is no missing information for an agent to use this tool correctly.

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

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

The input schema is empty (no parameters), so schema coverage is 100%. The description adds value by clarifying that IP pools are for DHCP/PPP, which gives context beyond the empty schema. Baseline for 0 parameters is 4, and the description meets that.

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?

Description clearly states the tool lists IP pools and defines them as IP ranges for DHCP/PPP. The verb 'Daftar' (list) and resource 'IP pool' are specific. It implicitly distinguishes from sibling tools like address_lists or dhcp_leases by focusing on pool management.

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

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

The description implies usage when one needs to view IP pool settings, but provides no explicit guidance on when to use this tool versus alternatives (e.g., address_lists for address ranges). No exclusions or context cues are given.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as read-only, idempotency, or data freshness. For a tool with zero annotation coverage, the description must carry the behavioral burden, but it merely restates the name.

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

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

The description is a single, short sentence that front-loads the key term 'Active'. It contains no redundant words and efficiently communicates the tool's purpose.

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