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 tool fetches and saves a timestamped copy, which is non-destructive, but does not mention permissions, side effects, or error behavior. It adds some value 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 short and front-loaded with the key action. Every sentence adds value: purpose, what it does, return values, and parameter explanation. 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?

Given the tool has an output schema (presumably documenting return structure), the description covers the main behavioral aspects. However, it lacks details on failure modes, device accessibility, or prerequisites, 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 description coverage is 0%, but the description adds meaning to the 'device' parameter by specifying it is 'as defined in devices.yaml'. This clarifies the source of device names, which is not in the schema. It compensates for the lack of schema documentation.

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

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

The description clearly states the tool's main action ('Backup the running configuration') and specifies the resource (network device) and outcome (saves timestamped copy locally). This distinguishes it from sibling tools like 'compare_configs' or 'show_routing_table'.

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 for backing up device configurations but does not explicitly state when to use this over alternatives like 'compare_configs' or when not to use it. The context is clear from the purpose, so it's adequate but could be improved.

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 behavior. It mentions creating a YAML file connecting to management IPs, but does not state side effects (e.g., overwriting, file location) or requirements (e.g., permissions, existing lab).

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 a front-loaded main sentence and a brief Args block. No redundant phrases; it efficiently conveys the tool's purpose and parameter.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description provides the core purpose. However, it lacks details on output behavior (e.g., whether the YAML is returned or saved) and does not compensate for missing annotations.

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

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

The description includes an Args block explaining the single parameter 'scenario' as the lab scenario to generate for, adding meaning beyond the schema's minimal type and default.

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 generates a devices.yaml for a Containerlab lab, connecting to management IPs for MCP-Telecom use. It distinguishes from siblings like clab_generate by specifying the exact file type, though not explicitly differentiating.

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 use after containerlab deployment but lacks explicit guidance on when to use this tool vs alternatives like clab_generate. No exclusions or prerequisites are provided.

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

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

The description lacks details on side effects: does it write to disk, return the YAML, or overwrite files? No annotations are present, so the description should cover these traits. It mentions 'creates' but does not clarify the interaction with the filesystem or required inputs like devices.yaml.

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: a brief sentence followed by a structured arg list. No filler content. While the docstring style is acceptable, it could be slightly more compact, but overall 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?

The description omits important context: it does not explain the output (despite an output schema being present), nor mention prerequisites like the existence of devices.yaml for the inventory scenario. The tool's role in a workflow is not fully specified.

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 compensates by listing the possible values for 'scenario' (basic, mpls_core, datacenter, isp_edge, inventory) and explaining the inventory option uses devices.yaml. This adds essential 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 it generates a Containerlab topology YAML file for lab testing, specifying it can mirror inventory or use a test scenario. The parameter 'scenario' lists distinct options, distinguishing it from sibling tools like clab_scenarios.

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., clab_devices_yaml, clab_scenarios). There is no mention of prerequisites or when not to use it, leaving the agent without context for tool selection.

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

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

No annotations provided. Description only says 'list', implying read-only but does not explicitly state no side effects, auth needs, or rate limits. For a simple list, minimal transparency but still could be improved.

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

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

Two sentences, front-loaded with action and resource, no wasted words. Highly concise and well-structured.

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

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

For a simple listing tool with no parameters and an output schema, the description adequately covers what it does and why. Could mention output format if not covered by output schema, but schema exists.

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

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

No parameters in schema, so description adds context about the content (Containerlab scenarios) without needing parameter explanations. Baseline 4 for zero-param 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?

Clearly states the verb 'List' and the resource 'Containerlab test scenarios', with context of pre-built topologies for testing without production access. Distinguishes from siblings like clab_generate which creates scenarios.

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?

Implies usage for testing without production network access but does not explicitly state when to use this tool versus alternatives like clab_generate or clab_devices_yaml. No when-not-to-use guidance.

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

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

No annotations are provided, so the description must fully convey behavior. It states it performs a diff and highlights changes, but does not mention that it is read-only (no side effects), what happens if the backup file is missing, or any authorization requirements. The description is adequate but leaves some 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 concise and well-structured: a clear title sentence, a brief summary of the operation, and a parameter list. It is front-loaded with the most important information and contains 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?

For a simple comparison tool with a good output schema, the description covers purpose and parameters adequately. However, it lacks usage guidelines and does not explicitly state that the operation is non-destructive. Given the tool's simplicity, it is mostly complete but could be slightly more 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 input schema has 0% coverage (no descriptions for parameters). The description compensates fully by explaining each parameter: 'device: Name of the device as defined in devices.yaml' and 'backup_file: Path to the backup file to compare against'. This adds essential 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 explicitly states 'Compare the current running config with a previous backup' and further details that it performs a diff between live running config and a saved backup file, highlighting additions and removals. This clearly distinguishes it from sibling tools like 'compare_devices' or 'backup_config'.

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

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

The purpose is very clear, implying when to use it (to compare running config with a backup). However, it does not explicitly state when not to use it or mention alternatives, such as using 'compare_devices' for inter-device comparisons. This is a minor gap.

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 reveals it runs the same operation on multiple devices and highlights differences, but does not disclose specifics like output format, error handling, or potential performance impact.

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: three sentences plus an Args section. Front-loads the main action and use case, 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?

For a simple tool with two parameters and an output schema, the description covers the main behavior and parameters. It could benefit from mentioning error conditions (e.g., device unreachable) but is largely complete for its complexity.

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

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

Schema coverage is 0%, so description compensates well. It explains 'operation' with examples ('system_info', 'ntp_status') and 'devices' with default behavior ('Empty = all devices'). This adds significant 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 tool's purpose: 'Compare command output across multiple devices' with verbs 'compare' and 'runs the same operation on multiple devices and highlights differences'. It distinguishes from siblings like compare_configs (config comparison) and device-specific show commands.

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 'Useful for finding configuration drift or inconsistencies', indicating when to use. However, it does not explicitly state when not to use or mention alternatives like compare_configs for config differences.

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 states the tool checks a running config, implying a read-only operation without side effects. However, it does not explicitly confirm it is non-destructive, nor does it mention any prerequisites like device reachability or required permissions.

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 paragraphs plus an Args section. The introductory paragraph is concise and informative. The Args section repeats the parameter name from the schema but adds the helpful source reference. Overall, it is reasonably concise but could be tightened by merging the first two sentences.

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 single parameter and the existence of an output schema (not shown), the description adequately explains the tool's purpose and output format ('scored report with pass/fail per rule and remediation advice'). It does not mention prerequisites or error conditions, but for a straightforward check tool with one param, it is fairly 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 input schema has only one parameter 'device' with no description (0% schema coverage). The description adds meaningful context by stating the device name is 'as defined in devices.yaml', which tells the user where to find valid values, going beyond what the schema 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?

The description clearly states the verb 'Check' and the resource 'device's running config' against 'security best practices'. It lists specific areas like NTP, SSH, SNMP, AAA, passwords, which distinguishes it from many sibling tools that deal with show commands or backups. However, it does not explicitly differentiate from the closely related siblings 'compliance_check_rule' and 'compliance_list_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 implies usage when checking security compliance by describing the output (scored report with pass/fail and remediation). It does not provide explicit guidance on when not to use this tool or mention alternatives. Siblings like health_check or compliance_check_rule exist but are not referenced.

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, and the description only states 'Check a specific compliance rule against a device' without disclosing behavioral traits like read-only nature, side effects, prerequisites, or error conditions.

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: one-line purpose followed by two parameter descriptions. No redundant information, front-loaded with purpose.

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

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

Given the output schema exists, return value explanation is optional. However, the description lacks behavioral context (e.g., what 'check' means, success/failure indications). For a simple tool, it is 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?

Despite 0% schema coverage, the description adds meaningful context: 'device: Name of the device as defined in devices.yaml' and 'rule_name: Name of the compliance rule to check', clarifying the source and scope of values beyond the schema's generic 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 explicitly states the verb 'Check' and resource 'specific compliance rule against a device', clearly distinguishing it from sibling tools like compliance_check (likely bulk) and compliance_list_rules (list only).

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 compliance_check or compliance_list_rules. No when-not or alternative tools 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 the basic behavior (listing all rules with descriptions) but lacks details on side effects, permissions, or rate limits. For a simple read operation, the description is minimally adequate.

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 that conveys the necessary information without any fluff. Every word is essential.

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 annotations, and an output schema exists, the description is sufficient for understanding its purpose and return value. It is complete for a simple list 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 tool has 0 parameters, so the schema coverage is 100% by default. The description adds no parameter information, which is acceptable as there are none. Baseline 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 specifies the verb 'List' and the resource 'all available compliance rules', and states that descriptions are returned. This distinguishes it from siblings like compliance_check and compliance_check_rule.

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

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

The description implies that this tool is for listing, but it does not provide explicit guidance on when to use it versus alternatives, nor does it mention any prerequisites or exclusions.

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

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

With no annotations, the description must carry behavioral disclosure. It mentions connecting and collecting data, suggesting a read-only operation, but does not explicitly state that it is non-destructive, nor does it discuss authentication, rate limits, or error handling. The behavioral context is 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?

Two succinct sentences plus a one-line parameter description. Front-loaded with the action and outcome. No redundant or unnecessary information.

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

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

Given the tool has one parameter and an output schema (implied), the description adequately explains purpose, method, and parameter. It doesn't detail the output format, but that is covered by the output schema. Lacks differentiation from siblings but still functional.

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% (only title), but the description clearly explains the 'devices' parameter format (comma-separated) and default behavior (empty = all devices). This adds significant meaning beyond the schema, compensating 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?

Clearly states the tool discovers network topology by collecting LLDP data and building a topology map. The verb 'discover' and resource 'network topology' are specific. Distinguishes from sibling tools like show_lldp_neighbors or show_topology by focusing on discovery and map generation.

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?

Description indicates connecting to devices and collecting LLDP data to build topology, which implies usage for discovery. However, it does not explicitly state when to use this tool versus alternatives (e.g., show_lldp_neighbors for raw data, show_topology for existing map), nor does it provide exclusions 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?

Discloses algorithm (BFS) and data source (LLDP-discovered topology). No annotations provided, so description carries full burden. Could mention error handling or no-path scenarios but adds meaningful 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?

Extremely concise: first sentence states purpose, second adds algorithm, then parameter list. 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?

Output schema exists, so return values not needed. Covers algorithm and data source. Lacks details on error conditions or performance, but sufficient for a simple two-param tool.

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

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

Schema has 0% description coverage; description provides inline definitions for source and target as device names. Adds meaning but is minimal (no examples or format constraints).

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 finds the shortest path between two devices, using BFS on LLDP-discovered topology. This distinguishes it from sibling topology tools like show_topology or discover_topology.

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 vs alternatives (e.g., show_topology for full view). Usage is implied but no exclusions or comparison provided.

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

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

No annotations are provided, so the description carries the full burden. It mentions that the tool shows executed commands, timestamps, devices, and success status, indicating a read operation. However, it does not disclose potential side effects, authentication needs, or rate limits.

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

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

The description is concise with two sentences and an Args line. It is front-loaded and each sentence serves a purpose without extraneous content.

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

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

An output schema exists, so return value details are covered externally. The description adequately describes what the log contains (commands, time, device, success). It is slightly lacking in specifying ordering or time range, but 'recent entries' is sufficient for a simple tool.

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

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

The schema has 0% description coverage, so the description must add value. It explains that 'count' is the number of recent entries to retrieve (default: 25), which clarifies the parameter's role beyond the schema's type and default.

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 'Retrieve' and the resource 'command audit log'. It is specific and uniquely identifiable among sibling tools, as no other sibling deals with audit logs.

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

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

The description implies usage for viewing command history but provides no explicit guidance on when to use this tool versus alternatives (e.g., when not to use it). No exclusion criteria or alternative references 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?

The description discloses key behaviors: SSH connectivity testing and response time measurement, and all-device check when no device specified. However, without annotations, it does not cover potential failure modes, impact, or response details. 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?

The description is concise with 3 sentences, front-loading the purpose and then explaining parameters. Every sentence adds value without repetition or fluff.

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

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

For a simple health check tool with one optional parameter and an output schema (though not shown), the description sufficiently covers behavior and parameter usage. It leaves little ambiguity for the agent to invoke the tool correctly.

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

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

Schema coverage is 0%, so the description's explanation that 'device' is an optional name and omitting it checks all devices adds essential meaning. This compensates well for the schema's lack of documentation, though no additional examples or formats are given.

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

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

The description clearly states the tool 'Check reachability and response time for devices' and specifies it tests SSH connectivity. This verb+resource pair is specific and distinct from sibling tools like parallel_health_check which likely does bulk checks.

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 that omitting the device parameter checks all devices, providing some usage context. However, it lacks explicit guidance on when to use this tool versus alternatives like parallel_health_check for multiple devices, or when to use other check 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 carries the transparency burden. It explains that capabilities are based on vendor type, implying a read-only lookup, but does not explicitly state side effects, auth needs, or performance impact. It is adequate but could be more explicit.

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, with a clear main sentence followed by a brief explanation of usage and a parameter note. Every sentence adds value, and it is well front-loaded.

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

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

Given the tool's simplicity (one parameter, output schema exists), the description fully covers what an agent needs: purpose, parameter definition, and how to use the output. No gaps are present.

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

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

The schema has 0% coverage, but the description adds meaniningful context: the device parameter is 'Name of the device as defined in devices.yaml', which clarifies the source and format, compensating well for the 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?

The description clearly states the tool lists all supported operations for a device, with a specific verb and resource. It distinguishes from siblings by focusing on capabilities and references the related 'run_vendor_operation' tool, making its 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?

Provides explicit guidance to use the operation names with run_vendor_operation, showing how to apply the output. However, it does not compare with similar tools like netconf_capabilities or specify 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 provided, so the description carries full burden. It discloses return fields but lacks details on authentication, rate limits, or side effects. For a read-only listing, this is minimally adequate.

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

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

Two sentences with no extraneous information. The description is front-loaded with the main purpose and concisely lists return fields.

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 and an output schema assumed to document return fields, the description covers the tool's complete behavior. No gaps remain.

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 baseline 4 applies. The description correctly indicates no parameters are 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 'List all configured network devices' and specifies the returned fields (names, hosts, vendors, ports). This distinguishes it from sibling tools like show_interfaces or show_bgp_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 on when to use this tool vs alternatives. Among many sibling tools, there is no mention of when listing devices is appropriate or when to use device-specific tools instead.

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, and the description lacks behavioral details such as read-only nature, permissions required, side effects, or performance impact.

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 two sentences plus an Args section, front-loading the purpose without extraneous text.

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

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

Given the presence of an output schema, the description adequately covers the tool's function and parameter, though it omits mention of network connectivity or prerequisites.

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 'device' parameter as 'Name of the device as defined in devices.yaml', adding meaningful context beyond the schema's simple type definition.

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 NETCONF/YANG capabilities and shows YANG modules supported, but does not differentiate from the sibling tool 'list_device_capabilities'.

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 for understanding available structured data before retrieval, but provides no explicit guidance on when to use this tool versus alternatives or 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. It discloses that the tool uses NETCONF, returns structured XML, and requires the ncclient library. However, it does not mention authentication, error handling, or what happens if NETCONF is not enabled on the device, leaving some behavioral gaps.

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

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

The description is only 4 lines, front-loaded with the purpose, and every sentence is informative. No fluff or repetition.

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

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

Given the tool has 2 parameters, no annotations, and an output schema, the description covers the main aspects: purpose, parameters, protocol, and output format. It could mention that NETCONF must be enabled on the device, but this is a minor omission.

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

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

Schema coverage is 0%, meaning the schema provides no descriptions. The description compensates fully by explaining both 'device' (name from devices.yaml) and 'source' (datastore options: running, candidate, startup) with clear context.

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 'Retrieve', the resource 'device configuration', and the protocol 'NETCONF'. It distinguishes from siblings like 'run_command' (SSH CLI) and 'netconf_get_operational' by explicitly stating it returns structured XML/YANG configuration data.

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

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

The description implies usage context: use this tool when you want structured configuration data via NETCONF, not SSH CLI scraping. While it does not explicitly exclude cases or name alternatives, sibling tool names like 'run_command' and 'netconf_capabilities' provide context. It also documents the device and source parameters.

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 mentions pre-defined YANG filters but does not disclose side effects (none expected), network dependencies, or error behavior. Minimal transparency for a NETCONF 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?

Concise and well-structured: main purpose first, then supported operations, then parameter list. 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?

Output schema exists, so return values need not be explained. Covers parameters and operations, but could state that listed operations are exhaustive and mention error handling or device reachability. Mostly complete for a simple tool.

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

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

Schema provides no parameter descriptions (0% coverage). Description adds basic meaning for device (from devices.yaml) and operation (with examples), but lacks format constraints or exhaustive list. Compensates partially.

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 retrieves operational state via NETCONF using YANG models and lists supported operations. This distinguishes it from sibling tools like netconf_get_config and show_ commands, but does not explicitly differentiate.

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 siblings. Does not mention prerequisites, when not to use, or alternatives. Only lists operations without context about choosing this over specific show_ commands.

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 annotations, the description carries full burden. It repeats that the command must be read-only and mentions the thread pool and max_workers, but does not address error handling, partial failures, or authorization needs.

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 well-structured: a purpose sentence, a performance note, then bullet-point Args. No redundant words; every sentence adds value.

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

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

Given the tool's complexity and the presence of an output schema, the description covers the main aspects: purpose, parameters, and safety. It omits error handling and timeouts, but the output schema likely documents return values.

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

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

Despite 0% schema description coverage, the description fully explains each parameter: command must be read-only, devices are comma-separated (empty = all), max_workers defaults to 10. This adds substantial meaning beyond the schema 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 the tool runs a read-only command on multiple devices simultaneously, distinguishing it from single-device tools like run_command by emphasizing parallel execution via a thread pool.

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 'Much faster than querying one-by-one,' implying it should be used for bulk commands. However, it lacks explicit when-not-to-use guidance or alternative tools, though context suggests it's for read-only bulk operations.

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

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

No annotations are provided, so the description carries the full burden. It discloses parallel testing of SSH reachability and response time but lacks details on concurrency limits, error handling, or idempotency. Given no annotations, more behavioral context would be helpful.

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 brief and well-structured: one-line summary, one-line benefit, then an Args section. Every sentence 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?

For a simple one-parameter tool with an output schema, the description adequately explains input behavior and parallel nature. It could mention output format or concurrency details, but overall it is sufficient.

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

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

The description adds meaning beyond the schema: explains that devices is a comma-separated string and empty means all devices. Schema coverage is 0%, so the description compensates well for the single parameter.

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

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

The description clearly states the tool health-checks multiple devices in parallel, specifying tests for SSH reachability and response time. It implicitly distinguishes from sequential health_check sibling by highlighting speed advantage.

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 use when fast multiple-device health checks are needed, contrasting with sequential methods. However, it does not explicitly state when not to use or explicitly name alternatives like health_check.

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

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

The description discloses parallel execution and vendor CLI translation but does not mention safety or side effects. With no annotations, the description carries the burden and provides basic behavioral info but lacks detail on destructive potential or error handling.

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

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

The description is concise, with a clear purpose statement and a structured Args section. Every sentence adds value, though it could be slightly more streamlined.

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

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

Given the output schema exists (not shown), the description effectively covers purpose, parameters, and behavior. It may lack error handling details, but is adequate for a parallel execution tool.

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

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

Schema description coverage is 0%, but the description's Args section provides clear, meaningful descriptions for all three parameters (operation, devices, max_workers), including defaults and special meaning (e.g., empty devices = all). This fully compensates 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 the tool runs a vendor-mapped operation on multiple devices simultaneously, using a specific verb and resource. It distinguishes from siblings like run_vendor_operation (likely single device) and parallel_command (raw command).

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

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

The description implies when to use (vendor-mapped operations on multiple devices) but does not explicitly compare to alternatives or state when not to use. No exclusions are provided.

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

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

No annotations are provided, so the description carries the burden. It describes the output (counts of connections) but does not declare read-only status or any potential side effects. For a simple stats tool, this is acceptable but could be more explicit.

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

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

The description is extremely concise at two sentences (27 words) and immediately states the action and output. No redundant information.

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

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

Given no parameters, no annotations, and that the tool has an output schema (per context signals), the description is complete: it explains what the tool returns and its purpose. It sufficiently distinguishes from many sibling tools.

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

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

There are no parameters, so the schema coverage is 100%. The description does not need to add parameter meaning. Baseline for zero parameters 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 shows connection pool statistics, specifically active, idle, and total persistent SSH connections per device. This distinguishes it from sibling tools like show_interfaces or show_cpu.

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 it is useful for monitoring connection reuse, but does not explicitly state when to use it versus alternatives or provide any when-not-to-use guidance. Adequate but not prescriptive.

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 takes full responsibility. It discloses the read-only restriction, allowed command prefixes, and that configuration commands are blocked. It does not detail output format or error handling, but the presence of an output schema (not shown) likely covers return values.

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: a purpose sentence, a safety/usage sentence, and a formatted Args section. Every sentence adds value, and the most critical information (purpose and restriction) 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 two-parameter tool, the description covers purpose, usage context, parameter details, and constraints. With an output schema (exists but not shown), return values are presumably documented elsewhere. The description adequately fills in the gaps left by the absence of annotations and schema descriptions.

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 no descriptions (0% coverage). The description adds that 'device' is from devices.yaml and that 'command' must start with specific prefixes, providing essential meaning 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 'Run any read-only (show) command on a network device,' which is a specific verb and resource. It distinguishes itself from sibling tools by noting it's for commands not covered by dedicated tools.

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

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

Explicitly says 'Use this when you need a specific command not covered by the dedicated tools,' and specifies that configuration commands are blocked, providing clear when-to-use and when-not-to-use guidance.

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

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

No annotations provided, so the description carries full burden. It explains the translation mechanism but omits details on side effects, authentication, error handling, and output format. The presence of an output schema mitigates the last point slightly.

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 two short paragraphs, front-loading the main purpose. Every sentence adds value without fluff.

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

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

While the description covers the basic functionality, it lacks details on handling invalid operations or device errors. The output schema may fill some gaps, but the description alone feels incomplete for a tool with vendor-specific mapping.

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 (0% coverage). The description compensates by specifying that `device` is from `devices.yaml` and `operation` is a named operation with examples. This adds significant meaning.

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 runs a named operation by translating it to a vendor-specific CLI command. It distinguishes from siblings like `run_command` which executes arbitrary commands.

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 advises using `list_device_capabilities` to see available operations, providing useful guidance. However, it does not explicitly state when not to use this tool or contrast with alternatives like `parallel_operation`.

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

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

No annotations are provided, so the description carries the burden. It discloses that it returns alarm conditions with severity, timestamp, and description, but does not explicitly state read-only nature or behavior on invalid devices.

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

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

Two concise sentences plus an arg description with no unnecessary information; every sentence serves a purpose.

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

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

Given one parameter, no annotations, and an output schema (so return values need not be detailed), the description adequately covers purpose, parameter, and return fields. It could mention response for empty alarms but is otherwise 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 0% schema description coverage, the description explains the 'device' parameter's meaning ('Name of the device as defined in devices.yaml'), adding valuable context beyond the schema property name.

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

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

The description states it shows active alarms and alerts on a network device, which is specific and distinct from sibling tools like show_arp_table or show_bgp_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?

The description implies usage for checking alarms but does not provide explicit guidance on when to use this tool over alternatives or 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, and the description does not disclose behavioral traits like read-only nature, required permissions, or potential side effects. It only states what is returned.

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 only two sentences plus a parameter explanation. Front-loaded purpose, no redundant information.

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

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

Given the existence of an output schema, the description does not need to detail return values. However, it lacks information on pagination, filtering, or constraints. Adequate for a simple tool 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?

The sole parameter 'device' has zero description coverage in the schema. The description adds critical context: 'Name of the device as defined in devices.yaml', which compensates for the lack of schema documentation.

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

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

The description clearly states 'Show the ARP table on a network device' and specifies the resource (ARP table) and action (show). It is distinct from sibling tools like show_mac_table or show_routing_table.

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 such as show_mac_table or show_routing_table. The description does not provide usage context or exclusion criteria.

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 discloses the return details (state, AS, messages, hold time) and implies a read-only operation without side effects; lacks explicit state change info.

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 sentences plus an Args section, front-loaded with the main purpose, no unnecessary words; well-structured for quick understanding.

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

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

Given the simple single-parameter tool and existence of an output schema (not shown), the description provides sufficient context; could mention prerequisites like BGP configuration but overall 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?

The description defines the 'device' parameter as 'Name of the device as defined in devices.yaml', adding crucial context beyond the schema's type-only definition, compensating for 0% schema coverage.

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

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

The description clearly states the verb 'Show' and the resource 'BGP neighbor information' on a network device, distinguishing it from sibling tools like 'show_bgp_summary'.

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 'show_bgp_summary' or other show commands; the description only lists the device parameter.

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

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

No annotations exist, so the description bears full burden. It discloses what is returned but does not mention any side effects, authorization requirements, or underlying method (e.g., CLI, SNMP). 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 a clear purpose and an Args section. It could be slightly more structured, but every sentence adds value.

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 an output schema (not shown) and a single parameter, the description covers the essential aspects. It explains what data is returned, which is sufficient for 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 parameter 'device' lacks description in the input schema (0% coverage). The description adds meaning by specifying it should be the device name as defined in devices.yaml, which compensates for the schema gap.

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

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

The description clearly states the tool shows BGP neighbor summary and specifies the returned data (neighbor states, prefixes, uptime). However, it does not explicitly differentiate from the sibling tool 'show_bgp_neighbors', which may have overlapping functionality.

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 implicit usage context by stating it works across all supported vendors, but lacks explicit guidance on when to use this tool versus alternatives like 'show_bgp_neighbors'.

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 like the method of data collection, potential performance impact, or required user roles. It only describes the output but not side effects or constraints.

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 purpose. Although the Args section is integrated, there is no redundancy. It earns its place without wasted words, though it could be slightly improved by integrating the parameter description into the prose.

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

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

The description provides a good overview of the output scope and parameter source, and an output schema exists so return values are covered. However, it lacks usage guidelines and behavioral transparency, leaving gaps for a single-parameter tool.

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

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

Schema coverage is 0% but the description adds meaningful context for the sole parameter 'device', stating it is 'the name of the device as defined in devices.yaml', which clarifies the source of valid values beyond the schema's simple 'Device' label.

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 'Show CPU utilization on a network device' and specifies 'Returns CPU usage per core/process to identify resource bottlenecks', providing a specific verb and resource that distinguishes it from sibling tools like show_memory or show_environment.

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 does not provide guidance on when to use this tool versus alternatives. It lacks context about prerequisites, such as requiring device connectivity or permissions, and does not 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 exist, so the description carries the full burden. It informs that the tool lists neighbors via LLDP/CDP, implying a read-only operation. However, it does not disclose any potential side effects, authentication needs, or performance impacts beyond the obvious.

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 main purpose. The 'Args' section is slightly redundant given the schema, but overall it is concise without unnecessary detail.

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

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

Given the low complexity (1 parameter) and existence of an output schema, the description is adequate but lacks guidance on when to use this tool over similar siblings and does not specify the output format. It meets the minimum requirements but leaves room for improvement.

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 add value for the single parameter 'device'. It provides 'Name of the device', which is a minimal but sufficient clarification of what is expected. The parameter name is self-explanatory, so the description adds marginal improvement.

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 'Show all discovered neighbors for a specific device' and mentions the protocols (LLDP/CDP). The verb and resource are clear, but it does not differentiate from the sibling tool 'show_lldp_neighbors', which might have a more specific scope.

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

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

No guidance is provided on when to use this tool versus alternatives like 'show_lldp_neighbors' or 'show_topology'. The description does not mention exclusions or 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 must fully convey behavioral traits. It only mentions the type of readings returned (power, fan, temperature) but omits critical details like whether it is read-only, destructive, or requires special permissions. The description does not disclose side effects or safety profile.

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

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

The description is extremely concise with three short sentences: a title line, a returns line, and an args line. It is front-loaded with the main purpose and contains no unnecessary words, earning its brevity.

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

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

The tool is simple with one parameter, and an output schema exists (based on context signals). The description explains the input and general output content. It is nearly complete; the only minor gap is not stating that the output schema provides detailed structure, but that is acceptable given its presence.

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 0% description coverage for the single parameter 'device'. The description adds meaningful context: 'Name of the device as defined in devices.yaml', specifying the expected format and source. This compensates well for the schema's lack of documentation.

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

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

The description clearly states the tool shows environmental monitoring on a network device and specifies it returns power supply, fan, and temperature sensor readings. The verb 'Show' and resource 'environmental monitoring' are specific and distinct from sibling tools like show_cpu or show_system_info.

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 does not provide any guidance on when to use this tool versus alternatives. It lacks explicit context about prerequisites, exclusions, or comparisons to other show tools, leaving the agent to infer usage without direction.

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

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

No annotations provided, so description carries full burden. It discloses what data is returned and that it's read-only (implied), but does not mention potential side effects, permissions, error conditions, or performance characteristics. Adequate but not comprehensive.

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, with the main purpose in the first line, followed by a list of returned data and clear argument descriptions. Every sentence adds value; 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 that an output schema exists (not shown), the description does not need to detail return values. It adequately covers what the tool does, what parameters are needed, and what data is returned. Minor missing details like device reachability assumptions are acceptable for this level of specificity.

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 compensates by explaining both parameters: device as defined in devices.yaml, and interface with examples (Gi0/0/0, 1/1/1, ge-0/0/0). This adds meaning beyond the schema's bare string 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 the verb 'Show' and the resource 'detailed statistics for a specific interface', listing the types of statistics returned (counters, errors, CRC, drops, utilization, MTU, speed). It distinguishes from sibling tool 'show_interfaces' which likely provides a summary of all 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 implies usage for detailed interface stats but does not explicitly state when to use this tool vs alternatives like 'show_interfaces'. It lacks when-not-to-use or alternative recommendations, leaving the agent to infer 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. Description implies read-only operation via 'Show' but does not explicitly state safety, authorization needs, or performance characteristics. It does describe return content, which is basic.

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 and to the point. The Args section directly addresses the parameter. No redundant sentences. Could be slightly more compact, but it's 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?

Output schema exists, so no need to detail return structure. Covers main purpose and parameter, but misses prerequisites (e.g., device reachability) and error conditions. Adequate for a simple 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?

Only parameter 'device' has no schema description (0% coverage). The description adds context: 'Name of the device as defined in devices.yaml', specifying where the device name comes from.

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 'Show interface status summary on a network device' and lists returned fields (admin/operational status, speed, description). Distinguishes from sibling 'show_interface_detail' by using 'summary'.

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 show_interface_detail or show_alarms. Does not mention scenarios where this is preferred.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions returned data (LAG member ports, states, aggregate bandwidth) but does not disclose any behavioral traits such as whether it requires privileges, if it has any side effects, or how errors are handled. The description is very 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 concise with a brief overview and an explicit args section. It is front-loaded with the main purpose and avoids unnecessary words. However, the structure could be improved by integrating parameter descriptions more naturally.

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 only one parameter and an output schema exists, the description provides adequate context about what the tool returns. However, it lacks context on prerequisites, such as whether the device must support LAG, and does not mention potential limitations.

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

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

Schema coverage is 0% and the description adds minimal detail: 'Name of the device as defined in devices.yaml'. This explains the parameter meaning but lacks format constraints, examples, or default values. For a single required parameter, more semantic information would be beneficial.

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 it shows Link Aggregation Group status, including member ports, states, and aggregate bandwidth. This is a specific verb+resource combination and distinguishes from sibling tools like show_interfaces which shows all interfaces without LAG aggregation details.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it does not clarify when to use show_lag_status instead of show_interfaces or other network status tools. The description only states what it does without 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 the full burden. It discloses that the tool returns neighbor info (system name, port ID, capabilities), which is accurate for a read operation. However, it does not mention prerequisites (e.g., LLDP must be enabled) or 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: two sentences plus a one-line parameter definition. No extraneous information. Key details are front-loaded in the first sentence, making it efficient for agent consumption.

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

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

Given the tool's simplicity (one parameter, output schema present), the description is complete: it states the purpose, the returned information, and the parameter meaning. No additional context is necessary for correct invocation.

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

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

Schema description coverage is 0%, but the description augments the parameter 'device' by specifying it as 'Name of the device as defined in devices.yaml', providing context beyond the schema's bare type definition. This helps the agent understand the expected source for device names.

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 shows LLDP neighbor discovery information, specifying the verb 'Show' and the resource 'LLDP neighbor discovery information'. It details the output: connected neighbors with system name, port ID, and capabilities, distinguishing it from other neighbor-related tools like show_device_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?

The description mentions it is 'useful for topology discovery', implying a use case, but does not explicitly state when to use this tool versus alternatives like show_device_neighbors or show_topology. No exclusions or when-not-to-use guidance is provided.

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

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

No annotations provided; description only says 'returns the most recent event log entries' without specifying count, output format, or any destructive/read-only traits. Lacks important behavioral context for an agent.

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 with two sentences and one argument clarification. No fluff, every part adds value.

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

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

Output schema exists, so return values are covered. However, lacks details on how many entries are returned or whether there is a default limit. Adequate but could be improved with more context.

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

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

Schema coverage is 0%, but the description adds meaning by specifying the device name 'as defined in devices.yaml', which is crucial for correct invocation. This compensates 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?

Description clearly states verb (show), resource (log/syslog messages), and scope (recent). Distinguishes from sibling tools like show_alarms or show_interface_detail.

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?

Implied usage for troubleshooting recent log events, but no explicit when-to-use or when-not-to-use compared to alternatives like health_check or show_alarms.

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 only states the output type but does not disclose any behavioral traits such as authentication needs, performance, or failure modes.

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 with three sentences: purpose, return values, and parameter explanation. It is well-structured and front-loaded with the main action.

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 show command with one parameter and an output schema, the description covers the basics. However, it lacks context about device reachability or prerequisites, which would make it 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?

The description adds meaning to the single parameter 'device' by specifying it is 'as defined in devices.yaml', which is not present in the input schema. With schema coverage at 0%, this added context is helpful but not extensive.

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 shows the MAC address table, specifying the resource (MAC table) and verb (show). It mentions the returned data (MAC addresses, VLANs, interfaces), distinguishing it from siblings like show_arp_table or show_routing_table.

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 over alternatives. It simply states what it does, leaving the agent to infer its applicability from the tool name and description.

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

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

With no annotations, the description should disclose behavioral traits. It only states output and parameter, omitting details like whether it is a read-only operation, network impact, authentication needs, or data freshness.

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 with three front-loaded sentences: purpose, output, and parameter. Every sentence is necessary and well-structured.

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

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

For a simple tool with one parameter and an output schema, the description covers purpose and parameter meaning. However, it lacks usage context and behavioral transparency, leaving gaps in complete 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?

The schema has 0% coverage, but the description adds meaning by explaining the 'device' parameter as a name defined in devices.yaml. This provides critical context beyond the bare string type.

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

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

The description clearly states the tool shows memory utilization on a network device and specifies output includes memory pool usage and free/used/total statistics. It is specific about the resource but does not differentiate from sibling show_* tools like show_cpu.

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 usage guidelines are provided. The description does not indicate when to choose this tool over alternatives such as other show_* commands, nor does it mention conditions 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, so description must carry burden. It mentions returns (LSP status, endpoints, bindings) but omits details like read-only nature, device reachability requirements, or error handling. 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?

Extremely concise: two sentences and an args block. No fluff, key information front-loaded. Ideal length for a simple tool with one parameter.

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

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

Has output schema (not shown), so description need not detail return format. Covers main outputs and the single parameter. Lacks some context on prerequisites (e.g., device must be accessible) but is reasonably complete given complexity.

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

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

Schema coverage is 0%, so description must explain parameters. It defines 'device' as name from devices.yaml, adding valuable context beyond the schema type string. Could elaborate on valid values or formatting.

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 shows MPLS Label Switched Paths on a network device and lists returned data (status, endpoints, bindings). It is specific and distinguishable from sibling show tools.

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

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

No guidance on when to use this tool versus alternatives like show_routing_table or other show commands. Implicit usage from name, but lacks explicit 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, so the description bears full responsibility for behavioral context. It mentions the tool is read-only (viewing) and device-specific, but does not disclose permissions needed, rate limits, or output behavior beyond a vague 'summary'. The description adds minimal value over the tool name.

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

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

The description is short and front-loaded with the core purpose. The use of 'Args:' is unnecessary but not detrimental. It avoids verbosity and every sentence adds information, though the structure could be tighter (e.g., merging the Nokia-specific lines).

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

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

Given the tool's simplicity (one parameter) and the existence of an output schema (which presumably details return values), the description provides a minimally adequate overview. However, it lacks mention of prerequisites (e.g., device reachability) or what constitutes a 'summary'. For a networking tool, this is acceptable 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 compensate. It adds a brief note that the 'device' parameter is a 'Name of a Nokia SR OS device', which clarifies its purpose but not its format or constraints. For a single required parameter, this is marginally helpful but not thorough.

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 shows a Nokia SR OS service summary, mentioning specific service types (VPRN, VPLS, SAP) and that it lists all configured services. This helps distinguish it from sibling tools like show_interfaces or show_mac_table. However, it could be more specific about what 'summary' includes (e.g., status, identifiers).

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 it is Nokia SR OS-specific and for viewing services, implying use when such information is needed. It does not explicitly state when not to use it or provide alternative tool names for similar queries (e.g., show_interfaces for interface details). The guidance is adequate but not comprehensive.

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

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

No annotations exist, so the description must cover behavioral traits. It implies a read-only operation but does not mention permissions, safety, or side effects. Basic transparency for a simple show command.

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 (two sentences) and structured with an Args section. No extraneous content; every sentence contributes value.

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

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

Given the presence of an output schema and the simple nature of the tool, the description lists all returned data. It is complete for its purpose.

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 only parameter 'device' is described as 'Name of the device as defined in devices.yaml', adding context beyond the schema. With 0% schema coverage, this 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?

The description clearly states 'Show NTP synchronization status on a network device' and enumerates returned fields (peers, stratum, offset, state). This verb+resource structure distinguishes it from sibling tools like show_interfaces or show_bgp_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?

The description lacks explicit when-to-use or when-not-to-use guidance. While the tool's purpose is obvious, no alternatives or context exclusion are provided.

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

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

Describes return values (states, interfaces, dead intervals) but does not disclose read-only nature, permissions, or potential side effects. No annotations are present, so the description carries the full burden; it is adequate but not comprehensive.

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 sentences plus a parameter line. Front-loaded with purpose. No redundant information.

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

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

Given an output schema exists, return value description is sufficient. Covers key aspects (states, interfaces, dead intervals). Could mention device existence requirement, but not critical for a straightforward show command.

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?

Only parameter 'device' is described with context 'as defined in devices.yaml,' adding value beyond the schema's basic type. With 0% schema coverage, this compensates well for a single parameter.

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

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

Description clearly states 'Show OSPF neighbor adjacencies on a network device.' with specific verb and resource, distinguishing it from sibling tools like show_bgp_neighbors or show_lldp_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?

Implies usage for OSPF neighbor adjacency, but no explicit guidance on when to use versus alternatives (e.g., show_bgp_neighbors) or when not to use. No prerequisites or context provided.

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

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

Without annotations, description indicates read-only operation by stating 'Show' and listing return fields. Does not disclose behaviors like error handling or authentication needs, but covers basic behavior.

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

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

Two sentences plus param description, front-loaded with purpose. No redundant information.

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

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

Simple tool with one param and output schema present. Description explains return fields adequately. Sibling tools are similar but description is sufficient for basic usage.

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

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

Single parameter 'device' has no schema description (0% coverage). Description adds meaning: 'Name of the device as defined in devices.yaml', clarifying source of device names.

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 shows the IP routing table on a network device, specifying returned fields (protocol, next-hop, metric, preference). This distinguishes it from sibling tools like show_arp_table or show_mac_table.

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 instead of alternatives (e.g., show_bgp_summary). No context on prerequisites or limitations.

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 does not explicitly state that the tool is read-only or has no side effects. The mention of 'returns' implies it is safe, but lacks explicit disclosure.

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

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

Two sentences plus an Args line. Front-loaded with main purpose. Every sentence adds value with 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?

Given an output schema exists, the description adequately lists return fields. Parameter is explained. However, no mention of limitations or prerequisites.

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 adds meaning: 'device: Name of the device as defined in devices.yaml' tells the agent where the value comes from and its purpose.

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 'Show' and the resource 'system information' and lists specific output fields (version, uptime, hardware). It distinguishes from sibling tools like show_cpu and show_memory by focusing on overall system info.

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. The description does not provide context such as 'Use for general overview' or suggest alternatives for specific hardware details.

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 behavioral burden. It discloses the tool is a read-only display operation ('show', 'displays') and that it requires prior data collection. No side effects or destructive actions are implied, which is accurate for a topology display 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?

Two sentences: the first states the main purpose and format, the second adds a prerequisite. No wasted words, front-loaded with key information. Highly concise and well-structured.

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

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

Given the tool's simplicity (0 parameters, output schema exists), the description fully covers what the tool does, its output format, and a necessary precondition. It is complete and leaves no ambiguity for an AI agent.

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

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

The tool has zero parameters, and schema coverage is 100% trivially. The description adds no parameter info, which is unnecessary. The baseline for no 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 clearly states it shows discovered network topology as an ASCII diagram, displaying devices and interconnections. It distinguishes from siblings like show_topology_json or show_topology_mermaid by specifying the output format as ASCII diagram, though it doesn't explicitly name alternatives.

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

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

The description explicitly states a prerequisite: 'Run discover_topology first to collect data.' This guides when to use the tool. It also implies usage context (after discovery) but does not explicitly state when not to use it or direct 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 are provided, so the description bears full burden. It indicates a read operation (export) and JSON output, which is sufficient for a simple export. However, it lacks details on potential impacts or prerequisites.

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

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

Two sentences, each serving a purpose. The first sentence is a clear verb-resource statement; the second adds context. 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 no parameters and an output schema, the description adequately covers the tool's purpose and output. Could optionally include an example structure, but not necessary.

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

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

There are zero parameters, so the description adds value by clarifying Output format. Baseline for 0 params is 4; the description fulfills this.

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 exports network topology as JSON, specifying both the resource and output format. It effectively distinguishes from sibling tools like 'show_topology' and 'show_topology_mermaid' which likely output other formats.

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 use cases: programmatic use or integration with visualization tools. This provides context but does not explicitly contrast with siblings or give when-not-to-use guidance.

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

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

No annotations exist and the description does not disclose behavioral traits such as read-only, destructive, or authentication needs. Merely states the export function without extra 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 concise sentence with a clarifying follow-up. It is front-loaded and contains 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?

For a tool with 0 parameters and an output schema, the description adequately explains the output format (Mermaid) and its usage context (rendering in Markdown, GitHub, docs). Complete given simplicity.

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 parameter semantics are irrelevant. Baseline 4 applies since schema coverage is 100% and no additional parameter info is needed.

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

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

The description clearly states the verb 'Export' and resource 'network topology as a Mermaid diagram', distinguishing it from siblings like show_topology (likely other format) and show_topology_json.

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., show_topology or show_topology_json). Lacks 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?

Describes what data it retrieves (system MIB, interface counts, uptime) and that it's a single request. However, with no annotations, it does not disclose potential side effects, rate limits, or authentication nuances beyond the community string.

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?

Concise two-paragraph structure with front-loaded purpose and clear parameter listing. No extraneous text, though could be more structured with bullet points.

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?

Covers tool purpose, data gathered, and parameter semantics. Output schema handles return values. However, lacks guidance on when to prefer over sibling SNMP tools or limitations.

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 description coverage, the 'Args' section adds crucial context: device is from 'devices.yaml' and community is for 'SNMPv2c'. This compensates for the schema's lack of 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 it gets a 'quick SNMP-based overview' of a device, specifying it polls system MIB, interface counts, and uptime. This distinguishes it from sibling tools like snmp_get (specific OIDs) and snmp_walk (subtree walk).

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?

Implied usage for a quick overview via SNMP, but no explicit guidance on when to use this over alternatives like snmp_get or show_interfaces. Lacks 'when not to use' or specific context.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's read-only nature (polling/retrieving) and a dependency (pysnmp). However, it does not address error handling, timeout behavior, or potential side effects, which are relevant for a network polling 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 two short paragraphs and a bullet-like arg list. Purpose is front-loaded. It includes essential setup info (pysnmp) but avoids redundancy. Slight improvement could be made by integrating the arg descriptions more succinctly.

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

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

Given no annotations, an output schema exists (not shown here), and 3 parameters, the description covers the tool's core function and parameter semantics. It lacks details on output format, but the output schema likely covers that. It is complete enough for a straightforward SNMP GET tool.

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

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

The schema has 0% description coverage, but the description compensates by explaining each parameter: 'device' as defined in devices.yaml, 'oids' as comma-separated OIDs (with default), and 'community' as the SNMPv2c community string (with default). This adds significant meaning beyond the schema's bare fields.

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

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

The description clearly states the tool retrieves specific SNMP MIB values by polling OIDs. It uses specific verbs ('Poll', 'Retrieves') and identifies the resource (SNMP OIDs from network devices). The name 'snmp_get' and differentiation from siblings like 'snmp_walk' 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?

The description explains that it accepts OID names or dotted notation and requires pysnmp, but it does not explicitly state when to use this tool versus alternatives like snmp_walk or other SNMP tools. The usage context is implied but not explicitly compared to siblings.

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

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

No annotations provided, so description carries full burden. States 'Retrieves all OIDs' without mentioning timeout, rate limits, or read-only nature. Does not specify if the walk is blocking or any potential side effects on the device. 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?

Well-structured with an Args section. Sentences are focused. A bit verbose in the description (e.g., 'Useful for...' could be integrated), but overall efficient at 3 lines of text plus args.

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 parameters, no annotations, and an output schema (not shown), the description covers purpose and basic parameter meaning. Lacks information on error handling, pagination, or performance considerations. Could be more complete for a network retrieval 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?

With 0% schema description coverage, the description adds critical meaning: 'device' comes from devices.yaml, 'base_oid' defaults to IF-MIB ifTable, 'community' defaults to 'public'. However, it does not explain the format expected for 'device' (e.g., hostname vs IP). Good value but some gaps.

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

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

Clearly defines the action ('Walk an SNMP MIB subtree'), the resource ('network device'), and the scope ('all OIDs under the specified base OID'). Distinguishes effectively from sibling tools like snmp_get (single OID retrieval) and snmp_device_overview (device summary).

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 usefulness for 'interface tables, routing tables, etc.', but does not explicitly state when not to use (e.g., for a single OID, where snmp_get would be more appropriate). No comparison to alternatives, so guidance is implied rather than 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the tool provides instructions (likely read-only), but does not clarify side effects, safety, or whether it actually launches a process. Critical context like authentication needs or state changes is missing.

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 (4 lines) but the initial sentence is vague ('Get instructions'). Key details like the dashboard purpose and prerequisite are present, but the structure could be improved by placing the most actionable information first.

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 one optional parameter and an output schema (unseen), the description is minimally sufficient. It covers the tool's purpose and a prerequisite, but lacks details on the output format, expected behavior, or any usage notes. Completeness is adequate for a simple tool but leaves room for improvement.

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 only parameter 'port' is described in the Args section as 'HTTP port for the dashboard (default: 8080)', which merely restates the schema's default and type. With 0% schema description coverage, the description adds no meaningful semantic context beyond what the schema already conveys.

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 'Get instructions to start the web dashboard,' clearly indicating the tool provides guidance for launching the dashboard. It distinguishes from sibling tools like 'start_metrics_endpoint' by focusing on the web UI, though it could be more explicit about the verb (provide vs start).

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 the prerequisite 'pip install mcp-telecom[dashboard]' but does not specify when to use this tool versus alternatives. Since no sibling tool serves the same purpose, the usage context is implied but lacks explicit guidance on conditions or disclaimers.

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 discloses that the tool exposes an endpoint and tracks specific metrics, but it is ambiguous whether it actually starts a process or just returns instructions ('Get instructions to start'). No annotations are provided, so the description carries the full burden, and it partially lacks clarity on side effects or permissions.