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

The annotations already communicate that this is a non-read-only, idempotent, non-destructive operation. The description adds no behavioral detail beyond restating the action and does not clarify what acknowledgement changes about the alert state or how until_clear interacts with that state.

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 declarative sentence with no filler and the key action and resource are front-loaded. It is compact and readable, though slightly under-specified given the close sibling tools and richer operation semantics.

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

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

For a mutating alert operation, the description lacks operational context: when acknowledgement is appropriate, what side effects it has, and how it differs from unmuting. The schema and annotations cover parameters and safety, but not the situational guidance an agent needs to select this tool confidently among many alert-related siblings.

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

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

Schema description coverage is 100%, so alert_id, note, and until_clear are already documented meaningfully in the input schema. The description adds no parameter-level information, but the schema fully carries that burden, making a baseline score of 3 appropriate.

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

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

The description states a specific verb ('Acknowledge') and resource ('an alert in LibreNMS') and identifies how the alert is selected ('by ID'). It is clear and unambiguous, though it does not explicitly differentiate this from sibling tools like alert_unmute.

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 about when to use this tool versus alternatives such as alert_unmute or alerts_get. The description gives no context about whether this is the right choice for muting notifications, resolving an alert, or acknowledging only the current occurrence.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only product context ('from LibreNMS') and retrieval semantics, with no additional behavioral details such as not-found behavior or permissions. This is acceptable for a simple read operation.

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

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

A single front-loaded sentence communicates the tool's purpose with no filler or redundancy. Every word earns its place.

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

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

The tool is simple: one required parameter, read-only annotations, and an output schema present. The description is complete enough for an agent to select and invoke it correctly; no important operational detail is missing at this level of 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?

The schema already documents alert_id with a description and 100% coverage. The description's 'by ID' simply restates the parameter concept without adding format details, minimum semantics, or any meaning beyond what the schema provides. Baseline 3 applies.

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

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

The description uses a specific verb ('Get'), a specific resource ('a specific alert'), and the retrieval criterion ('by ID'). It clearly distinguishes this from sibling list tools like alerts_get and from alert_rule_get, which targets rules rather than alerts.

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

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

The description implies the tool is for retrieving one alert when the caller already knows its ID, but it does not explicitly state when to prefer this over alerts_get or mention any exclusions. The usage context is clear enough by implication, but not explicitly contrasted with 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?

Annotations already signal a mutating operation via readOnlyHint=false and destructiveHint=true, so the safety profile is covered without description help. The description itself adds no behavioral context beyond what the annotations provide—no mention of duplicate-rule handling, validation outcomes, or side effects. It is consistent with the annotations, so no contradiction.

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

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

A single, front-loaded sentence with zero filler. All necessary detail is delegated to the schema and annotations, which is the appropriate division of labor for such a simple tool.

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

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

For a one-parameter create tool with a comprehensive payload schema, an output schema, and annotations covering the mutating nature, the definition is nearly complete. The only real gap is the missing when-to-use guidance relative to alert_rule_edit and alert_rule_delete.

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

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

Schema description coverage is 100%, and the payload schema is exceptionally detailed: it enumerates required vs optional fields, defaults, allowed severity values, and includes a JSON example. Per the baseline rule, the description need not compensate since the schema fully documents the parameter semantics.

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

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

The description uses a specific verb ('Add'), a clear resource ('alert rule'), and a destination ('LibreNMS'). The create semantics are unambiguous against the sibling tools alert_rule_edit and alert_rule_delete, so an agent can select it correctly without inspecting the schema.

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

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

No guidance is given on when to use this tool versus alert_rule_edit, alert_rule_delete, or alert_rules_list. There are no stated prerequisites, such as needing valid device IDs or a formatted builder JSON, and no exclusions. The agent must infer the intent from the tool name alone.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=true, which cover the safety profile of a delete operation. The description adds little behavioral context beyond that, such as permanence or cascading effects, but it does not contradict the annotations.

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

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

The description is a single sentence that delivers the action, resource, scope, and identifier requirement with no filler. It is appropriately minimal for a one-parameter delete tool.

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

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

For a simple delete operation with one required parameter, destructive/idempotent annotations, and an output schema, the description provides all necessary orientation. An agent understands what to delete and how to identify the target.

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

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

Schema description coverage is 100%, and the only parameter rule_id is already documented as 'Alert rule ID to delete.' The description reinforces this by saying 'by ID' but adds no new semantic meaning 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 uses the specific verb 'Delete' with a clear resource 'alert rule' and identifies the lookup key 'by ID.' This makes the operation unambiguous and distinguishes it from sibling tools like alert_rule_get, alert_rule_add, and alert_rule_edit.

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 clearly implies when to use the tool: when an alert rule needs to be deleted and its ID is known. It does not explicitly mention alternatives or when-not-to-use conditions, but no sibling tool performs alert rule deletion, so the context is sufficient for correct 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?

The description only restates the operation ('Edit an existing alert rule') and adds no behavioral detail beyond annotations. With readOnlyHint=false and destructiveHint=true, an agent can infer mutation, but the description does not explain whether editing replaces the full rule or merges partial fields, or what destructive side effects may occur.

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

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

A single, front-loaded sentence with no filler. It immediately tells the agent what action is performed and on what resource.

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

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

The combination of detailed payload schema and annotations covers most operational context, but the description lacks guidance on update semantics (partial vs. full replacement) and what happens with omitted optional fields. For a mutation tool with destructiveHint=true, this is a meaningful gap despite the rich schema.

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

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

Schema description coverage is 100% and the payload parameter is extensively documented with field names, types, and constraints. The tool description itself contributes no additional parameter meaning, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Edit'), a resource ('existing alert rule'), and the domain ('LibreNMS'). This clearly distinguishes it from sibling tools like alert_rule_add, alert_rule_delete, and alert_rule_get.

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

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

The word 'existing' implies this tool is for modifying already-created alert rules rather than creating new ones, which provides clear context. It does not explicitly name alternatives or state when not to use it, but the purpose is unambiguous against the sibling set.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which covers the safety profile. The description adds no behavioral context beyond restating the read-only nature of the operation, but it does not contradict the annotations.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the action, target resource, and selection criterion immediately, making it easy for an agent to parse quickly.

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

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

For a simple one-parameter getter with full schema coverage, an output schema, and safety annotations, the description is minimally adequate to invoke the tool correctly. However, it fails to disambiguate from the similarly named alert_get_by_id, leaving a real selection gap in the broader tool context.

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

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

The input schema has 100% parameter description coverage, with rule_id described as 'Alert rule ID' and a minimum of 1. The description's reference to 'by ID' adds no semantic information beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly states a specific verb ('Get'), resource ('details for a specific alert rule'), and selection method ('by ID'). It is unambiguous about what the tool does, though it does not distinguish itself from the sibling tool alert_get_by_id, which appears to overlap in purpose.

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

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

No explicit guidance is given about when to use this tool versus alternatives such as alert_rules_list, alerts_get, or alert_get_by_id. The phrase 'by ID' implies the caller needs a rule ID, but the description does not state when this tool is preferred or when another tool should be used.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only that it comes from LibreNMS and returns a dict, but it fails to disclose that the list is paginated via limit/offset, which contradicts the literal 'List all' claim and could mislead an agent about the full result set.

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 appropriately short and front-loaded with the core action. The 'Returns: dict' line is low-value filler because an output schema exists, but it does not significantly hurt readability or structure.

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

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

For a simple read-only list with two optional parameters and a safe annotation profile, the description is minimally viable. The main gaps are the missing pagination caveat and lack of sibling differentiation, both of which matter for correct invocation when agents need 'all' rules or need to distinguish alert rules from alerts.

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

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

Schema description coverage is 100%, with limit and offset already documented, so the baseline is 3. The description adds no additional meaning about when to adjust these parameters or how pagination interacts with the 'all' claim, but it does not need to compensate for missing schema info.

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

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

The description states a specific verb and resource: 'List all alert rules from LibreNMS.' It is clear that this tool lists alert rules rather than individual alerts or template rules, so it is distinguishable in intent. However, it does not explicitly differentiate itself from sibling list/get tools, and 'all' is slightly misleading given the pagination parameters.

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

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

The description gives no guidance about when to use this tool versus alternatives such as alert_rule_get, alerts_get, or alert_templates_list. It does not mention when-not-to-use, exclusions, or any conditions that would route an agent to a sibling tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description is consistent with them. The description adds little beyond 'optional filters,' but since the annotations cover the safety profile, this is acceptable.

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

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

The description is a single, front-loaded sentence with no filler or unnecessary detail. It is concise and easy to parse, though it could have included a bit more value without becoming verbose.

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 read-only nature, the rich annotations, and the output schema, the description is sufficient for basic invocation. It does not mention pagination or how to fetch a single alert, but those are covered by schema defaults and the sibling naming convention.

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 provides 100% coverage with descriptions for all six parameters, including defaults and valid values. The description only refers generically to 'optional filters,' so it adds no parameter-level 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 uses a specific verb ('Get') and a clear resource ('alerts from LibreNMS'), and mentions optional filters, which conveys a list/query operation. It does not explicitly differentiate from alert_get_by_id, but the plural scope makes the distinction reasonably clear.

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

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

No guidance is given about when to use this tool versus alternatives like alert_get_by_id, alert_acknowledge, or alert_rules_list. The phrase 'optional filters' hints at flexibility but does not state conditions or scenarios.

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

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

Annotations already signal this is not read-only, not idempotent, and not destructive, so the description only needs to add behavioral context. 'Create a new alert template' accurately conveys the operation, but it does not disclose duplicate-handling behavior, validation expectations, or any side effects beyond creation.

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

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

The description is a single, front-loaded sentence with no wasted words. It does not repeat schema contents, though it offers little beyond the basic 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 nested payload schema and existing output schema, the description is minimally adequate for a create operation. However, it relies heavily on the schema for parameter semantics and does not provide guidance on when to choose create over edit or how the created template relates to alert_rules.

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

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

The schema description coverage is 100% and the payload schema itself provides detailed field descriptions, required fields, and an example. The tool description adds no parameter-level meaning, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Create'), a specific resource ('alert template'), and the system ('LibreNMS'), clearly distinguishing this from siblings like alert_template_edit, alert_template_get, and alert_templates_list.

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

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

The description implies 'use when you need to create a new alert template,' which is clear enough in context. However, it does not explicitly contrast with alert_template_edit or state when not to use it, leaving the alternative-selection reasoning partially implicit.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true, giving the agent a clear safety profile. The description itself adds no behavioral traits beyond the basic edit action, though it does not contradict the annotations. The full-replacement behavior is disclosed only in the schema, not in the description.

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

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

The description is a single front-loaded sentence with no filler or redundant phrasing. It says precisely what the tool does, and the schema is allowed to carry the detailed invocation details.

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 alone is sparse, but the rich input schema covers all required fields and flags the critical full-replacement behavior, while an output schema exists and annotations cover the safety profile. The only notable gap is the lack of explicit routing to alert_template_create for new-template scenarios, but that is inferable from the name and schema.

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

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

Schema description coverage is 100%, and the input schema fully documents the nested payload structure including template_id, name, template, title, title_rec, and alert_rules. The tool description itself contributes no parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Edit') with a specific resource ('existing alert template') and platform ('LibreNMS'), which clearly distinguishes it from alert_template_create and alert_template_get. The word 'existing' immediately signals that this tool modifies rather than creates.

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 explicitly state when to use this tool versus alert_template_create or other siblings. The phrase 'existing alert template' implies use for templates that already exist, and the schema's requirement to include template_id adds operational context, but no explicit alternatives or exclusions are provided in the 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which fully cover the safety profile. The description's 'Get' phrasing aligns with these annotations, and the presence of an output schema removes the need to describe return values. No additional behavioral disclosure is needed.

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

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

A single, concise sentence that contains only essential information: the action, the resource, and the selection criterion. No filler or redundancy.

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

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

For a one-parameter read-only tool with a complete input schema, an output schema, and safety annotations, the description covers everything needed for correct invocation. Nothing important is missing.

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

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

Schema description coverage is 100%: template_id is documented with type, minimum, and a description. The tool description adds no extra parameter-level meaning beyond what the schema already provides, so baseline 3 applies.

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

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

The description states a specific verb ('Get'), a clear resource ('specific alert template from LibreNMS'), and the access method ('by ID'). It clearly distinguishes from list- and mutation-oriented sibling tools like alert_templates_list, alert_template_create, and alert_template_edit.

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

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

The description implies the tool is for retrieving one known template by ID, which is enough for a simple getter. However, it does not explicitly mention when not to use it or point to alternatives such as alert_templates_list for listing all templates.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds little beyond that, and it does not mention pagination behavior or the fact that 'all' may be limited by limit/offset.

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 'Returns: dict' line adds minor value but is mostly redundant given the output schema exists.

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

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

For a simple read-only list tool with full parameter documentation, an output schema, and safe-operation annotations, the description is mostly sufficient. A brief note about pagination would make it fully complete, but nothing critical is missing.

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

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

Schema description coverage is 100%, so limit and offset are already fully documented. The description does not add any additional parameter-level meaning 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 uses a specific verb ('List') and resource ('alert templates') with a clear source ('LibreNMS'). It distinguishes itself from single-item tools like alert_template_get, though it doesn't explicitly name any sibling.

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

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

There is no guidance on when to use this tool versus alternatives such as alert_template_get or alert_rules_list. The only usage signal is the tool's name and the phrase 'List all,' which implies enumeration but offers no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds nothing beyond the schema about edge-case behavior (e.g., unmuting an already-unmuted alert), but with annotations present the bar is lower and there is no contradiction.

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

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

A single nine-word sentence that front-loads the verb and resource and contains zero filler. Every word earns its place.

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

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

For a single-parameter mutation with annotations and an output schema, the description is nearly sufficient. However, the large sibling list contains alert_acknowledge, a closely related operation, and the description offers no contrast to help an agent decide between acknowledging and unmuting an alert.

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

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

Schema description coverage is 100% — alert_id is already fully documented with type, minimum value, and a description. The tool description merely repeats 'by ID' and adds no extra meaning such as where to source the ID or how it maps to LibreNMS alert identifiers. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('unmute') with a clear resource ('alert'), system ('LibreNMS'), and method ('by ID'). It distinguishes itself from siblings such as alert_get_by_id, alerts_get, and alert_acknowledge — an agent can tell this is the inverse operation without opening any schemas.

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

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

The description gives no guidance on when to use this tool versus alert_acknowledge or alerts_get, and no prerequisites are stated (e.g., the alert must currently be muted, or that the ID typically comes from alerts_get). Usage is only implied by the verb, which is not enough for reliable 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds little behavioral context beyond the resource and query mechanism, but no contradiction exists and the output schema covers return structure.

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

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

A single front-loaded sentence states the action, resource, and mechanism with zero wasted words. It is appropriately sized for a tool whose schema and annotations carry most operational 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?

For a simple read-only search tool with full schema coverage and an output schema, the description is nearly complete. It could add a brief note about supported query types or pagination behavior, but those are already present in the parameter 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 description coverage is 100%, so the schema already documents query, limit, and offset. The description's phrase 'by search query' aligns with the query parameter but does not add meaning 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 states a specific verb and resource: 'Retrieve ARP entries from LibreNMS by search query.' The resource 'ARP entries' is distinct from sibling tools like fdb_lookup or ports_search_mac, so an agent can differentiate it without opening the schema.

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

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

The description implies usage when ARP entries are needed, and the schema details supported query formats like IP, MAC, and CIDR. However, it does not explicitly compare against alternative lookup tools, provide exclusions, or state when a different tool should be 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?

The description simply restates the operation without adding behavioral details. Annotations already convey readOnlyHint=false, idempotentHint=true, and destructiveHint=true, but the description does not explain side effects, which fields are overwritten, or any permission or rate-limit considerations.

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

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

A single, front-loaded sentence with no filler. Every element contributes to the agent's understanding of the tool's 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?

For a simple two-parameter edit with full schema coverage and an output schema, the description identifies the resource, system, and identifier. The schema and annotations carry most behavioral and safety context, though adding usage guidance would make it fully complete.

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

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

Schema description coverage is 100%, with bgp_id and payload both described in the input schema. The description adds no extra parameter semantics beyond restating the operation target.

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

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

States a specific verb ('Edit'), a clear resource ('BGP session'), and the lookup mechanism ('by ID'). It is immediately distinguishable from sibling tools such as bgp_session_get and bgp_sessions.

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

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

Provides no guidance on when to use this tool versus alternatives, such as when to prefer bgp_session_get for retrieval or how this relates to other BGP tools. The intended context must be inferred solely from the verb 'Edit' and the sibling tool names.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context beyond the ID-based lookup, which is already present in the schema's parameter description.

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

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

One short sentence with no filler, front-loading the action and resource. Every word contributes to meaning.

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

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

For a simple 1-parameter read operation with annotations covering safety and an output schema present, the description is minimally sufficient. It does not explain error behavior or prerequisites, but these are not critical for a straightforward get-by-ID 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 100% and the sole parameter bgp_id is described with a type, minimum, and description. The description's 'by ID' phrase merely restates the parameter's purpose, adding no additional semantics.

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

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

The description uses a specific verb ('Get') and resource ('BGP session from LibreNMS') and identifies the retrieval mode ('by ID'). It is clear enough to distinguish from sibling tools like bgp_sessions or bgp_session_edit, though it does not name them explicitly.

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

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

No guidance is given on when to use this tool versus alternatives such as bgp_sessions for listing sessions or bgp_session_edit for modifications. The 'by ID' phrase weakly implies use when an ID is known, but there is no explicit context or exclusion.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the source system (LibreNMS) and a redundant return-type note, but no substantive behavioral context such as pagination semantics or how filters combine. It does not contradict the annotations.

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

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

The description is short and front-loaded with the core purpose in the first sentence. The 'Returns: dict' line is somewhat redundant given the output schema, so it does not fully earn its place, but the overall size and structure are appropriate.

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

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

For a read-only list tool with an output schema and 100% parameter coverage in the schema, the description conveys the essential action and source. It does not mention pagination details beyond the limit/offset parameters or the singular sibling for single-session lookup, but these are discoverable. The description is slightly thin yet adequate for selection and 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 100%, so each of the 11 parameters is already documented in the input schema. The description's 'optional filters' generalizes the parameter set but adds no meaning beyond what the schema provides. A baseline score of 3 is appropriate because the schema carries the semantic load.

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

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

The description states a specific action and resource: 'List BGP sessions from LibreNMS with optional filters.' This clearly identifies what the tool does and avoids tautology. However, it does not explicitly contrast with the sibling tools bgp_session_get or bgp_session_edit, so differentiation relies mostly on the plural 'sessions' vs. singular naming.

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 phrase 'with optional filters' implies that this is the listing/filtering entry point for BGP sessions, which is useful contextual guidance. However, there is no explicit when-to-use, when-not-to-use, or reference to alternatives such as bgp_session_get for a single session or bgp_session_edit for modifications. The intended usage is implied rather than stated.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=true. The description adds the 'create or update' upsert behavior, but this is already evident from the tool name. It does not disclose side effects, which fields are overwritten, permission requirements, or consequences of providing/omitting bill_id. The description provides no meaningful behavioral insight beyond the annotations and name.

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

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

The description is a single eight-word sentence with no filler, making it concise and front-loaded. However, given the nested payload schema and the number of sibling tools, this is arguably too terse to be appropriately sized. It communicates the basic operation but misses the opportunity to add scoping or usage context.

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

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

Despite a rich input schema and the presence of an output schema, the description alone is incomplete for a tool with dual create/update modes and conditional fields. It fails to explain when each mode applies, how bill_id routes to update, or how this tool fits among the bill-related siblings. The schema compensates for parameter details, but usage context remains unresolved.

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

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

Schema description coverage is 100%, with the payload field description detailing bill_id, bill_name, ports, bill_type, and conditional quota/cdr fields. The tool description itself contains zero parameter information, so it neither enhances nor harms what the schema already provides. This fits the baseline 3 for full 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 states a specific operation, 'Create or update', and a specific resource, 'a bill in LibreNMS'. This clearly identifies the tool's purpose and separates it from sibling read/delete tools like bill_get and bill_delete. However, it adds minimal detail beyond the title and doesn't list any bill fields, so it is clear but not highly informative.

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

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

There is no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites. The description does not explain that bill_id is required for updates or that bill_name/ports are required for creation. The agent must infer usage entirely from the input schema and sibling names.

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

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

The annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description does not contradict these but also adds no behavioral detail beyond what the annotations convey.

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

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

The description is a single, efficient sentence with no filler or redundant phrasing. It states the essential information upfront and earns its place entirely.

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 destructive operation with complete annotations and an output schema, the description covers what is needed to select and invoke the tool correctly. No significant context is missing.

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

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

The input schema fully documents bill_id with type, minimum, requirement, and a description. The description's phrase 'by ID' simply echoes the schema's 'Bill ID to delete' without adding extra semantic 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 the action ('Delete'), the resource ('a bill'), and the identifying mechanism ('by ID'). This strongly distinguishes it from siblings like bill_get, bill_create_or_update, and bills_list.

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

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

The description makes the primary use case obvious: deleting a specific bill by ID. However, it provides no explicit guidance on when not to use this tool, nor does it reference any alternative such as bill_create_or_update for modifying a bill.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which fully covers the safety profile. The description adds no extra behavioral context beyond the obvious read operation, so it neither contradicts nor significantly enriches the annotations.

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

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

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

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 two-parameter schema, rich annotations, and the presence of an output schema, the description is complete enough for an agent to correctly invoke the tool. No critical behavioral or parameter context is missing.

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

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

Schema description coverage is 100%, so the schema already documents bill_id and period. The description adds no parameter-level detail beyond 'by ID', which matches the schema. Baseline 3 is appropriate since the schema carries the parameter semantics.

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

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

The description uses a specific verb ('Get') with a concrete resource ('a specific bill') and the access method ('by ID'). This clearly distinguishes it from sibling tools like bills_list, bill_graph, and bill_delete.

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 a clear use case: call this when you have a known bill_id and need a single bill. It does not name alternative tools or exclusions, but the 'by ID' qualifier provides enough contextual guidance for basic 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds that the output is an image, but it does not disclose details like image format, response wrapping, or any other behavioral traits. 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?

Two short sentences, front-loaded with the core action, and no filler. The alternative is mentioned in a single clarifying sentence, making the definition both 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 two-parameter tool with full schema coverage and safety annotations, the description tells an agent everything essential: what it produces (image), and what the alternative is for data (bill_graph_data). No critical details are missing 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 100%, so both bill_id and graph_type are already documented in the schema. The description does not add parameter-level meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific action and resource: 'Render a bill graph as an image.' It also distinguishes itself from the sibling bill_graph_data, which provides numbers, so an agent can immediately understand what this tool produces.

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 tells the agent when not to use this tool: 'For the underlying numbers rather than a picture, use bill_graph_data.' This clearly names the alternative and the condition for choosing it, leaving no ambiguity about 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety and side-effect profile is already known. The description adds no additional behavioral context such as data granularity, graph type implications, timezone handling, or output characteristics beyond what the schema and annotations already provide.

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

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

The description is a single compact sentence with no fluff, though 'from LibreNMS' is somewhat redundant given the tool context. It is front-loaded and efficient, but slightly thin in substance.

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

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

For a simple read-only two-parameter tool with an output schema, the mechanics of invocation are covered by the schema and annotations. However, the description alone does not fully disambiguate this tool from the many related bill graph/history siblings, so completeness is only minimally 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?

Schema description coverage is 100%, so the two parameters are already adequately described in the input schema. The tool description itself contributes no extra parameter-level meaning, placing it at the baseline for high 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 uses a specific verb ('Get') and a clear resource ('bill graph data'), so an agent can tell it is a read operation for billing graph information. It does not explicitly differentiate itself from sibling tools like bill_graph or bill_history_graph_data, so it misses the top score.

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

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

The description provides no guidance on when to use this tool versus alternatives. Given many sibling graph tools such as bill_graph, bill_history_graph, and bill_history_graph_data, an agent has no stated selection criteria, exclusions, or hints about which one fits a given request.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no behavioral context beyond 'Get,' such as pagination behavior, historical scope, or any other operational trait. It does not contradict the annotations, but it contributes no additional behavioral transparency.

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

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

The description is only one short sentence with no fluff, which is concise. However, it is under-specified for the complexity of the tool and its many sibling tools, so the brevity comes at the cost of useful content. It is not poorly structured, but it does not earn a higher score due to missing contextual 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 that an output schema exists, return values need not be described. However, the description omits any clarifying context about what type of bill history is returned, how pagination works, or how this differs from bill_history_graph and bill_history_graph_data. An agent would struggle to select this tool reliably among the many bill-related siblings.

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

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

Schema description coverage is 100%, with bill_id, limit, and offset all clearly documented in the input schema. The description itself adds no extra parameter meaning, but the schema carries the burden adequately, so the baseline score of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Get bill history from LibreNMS.' It communicates what the tool does at a basic level. However, with siblings like bill_history_graph, bill_history_graph_data, and bill_get, it does not differentiate which variant of history this returns, so it lacks the distinguishing clarity needed for a 5.

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

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

There is no guidance about when to use this tool versus alternatives such as bill_history_graph, bill_history_graph_data, or bill_get. The description simply states what it does without any context, exclusions, or conditions 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavioral context by specifying that the result is an image rather than raw data, which is especially valuable given there is no output schema.

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

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

Two short sentences, no filler, and the core purpose is front-loaded. The alternative tool reference is placed second, making the guidance easy to parse.

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

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

For a simple, low-complexity tool with full schema coverage and safety-relevant annotations, the description is complete. It explains what the tool produces (an image), identifies the correct alternative when raw numbers are needed, and all required parameters are documented.

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

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

Schema description coverage is 100%, and each parameter has a description, so the schema carries the param semantics. The description does not add extra meaning to bill_id, history_id, or graph_type, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Render a graph for a past billing period as an image', identifying the specific action, resource, and output type. It also distinguishes itself from bill_history_graph_data by noting the alternative is for underlying numbers rather than a picture.

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 tells the agent when not to use this tool: 'For the underlying numbers rather than a picture, use bill_history_graph_data.' This gives concrete routing guidance to the relevant sibling and clarifies the intended use case.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description's 'Get' wording is consistent with the safety profile. The description adds no further behavioral context beyond that, such as how invalid IDs are handled or what data is actually returned, but the low bar set by the annotations is met.

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

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

The description is a single sentence with no filler or redundant elaboration. It is front-loaded and easy to parse, though it mostly restates the tool's name rather than adding substantial new 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?

Despite having annotations and a complete input schema, the description leaves too much unresolved for correct tool selection. The existence of closely related sibling tools and the lack of any clarifying context about the relationship between bill_id and history_id means an agent may not confidently choose this tool over alternatives.

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

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

Schema description coverage is 100%, so all three parameters (bill_id, history_id, graph_type) are already documented in the schema. The description adds no additional semantic meaning, such as how the parameters interact or what the returned graph data represents, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Get') and resource ('bill history graph data') from LibreNMS, making the basic purpose clear. However, it does not differentiate this tool from closely named siblings such as bill_graph_data, bill_history_graph, and bill_history, so the purpose is clear at a surface level but not fully disambiguated.

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

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

The description provides no guidance on when to use this tool versus its many siblings. There is no mention of prerequisites, typical use cases, or when to prefer bill_history_graph_data over bill_graph_data or bill_history_graph.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds little beyond restating 'optional filters' found in the schema, but it does not contradict the annotations and the read-only behavior is consistent with 'List bills'.

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 front-loads the verb and resource, followed by the key feature (optional filters). There is no wasted wording, and it is appropriately sized for a simple listing tool.

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

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

With a full input schema, output schema, and safety annotations, the description is largely sufficient. It could add guidance on filter interaction or distinctions from related bill tools, but the structured data already covers parameter meanings and return shape, making the definition complete enough 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 100%, so the schema already documents each parameter (ref, limit, custid, offset, period). The description only says 'optional filters' without adding meaning beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('List') and resource ('bills from LibreNMS'), clearly conveying a plural listing operation. It distinguishes itself from sibling tools like bill_get or bill_delete by emphasizing listing with optional filters rather than fetching, deleting, or graphing a single bill.

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 you need a list of bills, potentially filtered, use this tool. However, it provides no explicit alternatives or conditions for when not to use it, nor does it reference sibling tools like bill_get for single-bill retrieval or bill_history for historical periods.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=false, so the mutation/side-effect profile is covered there. The description adds no extra behavioral context—no mention of prerequisites, duplicate handling, whether discovery runs, or required permissions—so it adds little beyond the annotations.

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

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

The description is one short, scannable sentence with no filler. It is slightly redundant with the tool name, but it adds the LibreNMS target. There is no structural waste, though it is brief enough that some would consider it under-specified.

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

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

Given the rich nested schema and available annotations, the description is minimally sufficient but not complete. It omits when to choose it over siblings, any behavioral caveats, and what side effects adding a device may have, which are noticeable gaps for a mutation tool with a nested payload.

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

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

Schema description coverage is 100%: the payload property documents every field, defaults, and conditional requirements (SNMP v1/v2c vs v3). The prose description adds nothing about parameters, but with full schema coverage the description is not required to compensate. Baseline 3 applies.

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

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

The description states a specific action and resource: 'Add a new device to LibreNMS.' It is clear and unambiguous, and the name/title mirror it. However, it does not explicitly differentiate this from siblings like device_discover or device_update, so it stops short of a 5.

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

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

No guidance is provided about when to use this tool instead of siblings such as device_update, device_delete, or device_discover. The phrase 'Add a new device' implies intent, but there are no alternatives, exclusions, or conditions, 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safe read nature is covered. The description adds minimal behavioral context—it only names the source system and the fact that it retrieves availability. It doesn't describe output format, timing behavior, or what 'availability' encompasses, but with strong annotations the bar is lower.

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

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

The description is a single concise sentence with no wasted words. It is not front-loaded with extra fluff, and it uses a clear verb. Brief but appropriately sized for such a simple tool.

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

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

Given the tool only has one parameter, full schema coverage, an output schema, and strong safety annotations, the description covers the essential invocation context. It could mention what the response contains or distinguish from device_outages, but the overall package is reasonably complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter (hostname) adequately. The description adds no semantic detail about what hostname should be (e.g., FQDN vs display name), but the schema carries the weight, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Get device availability from LibreNMS.' This clearly identifies what the tool does. However, it does not explicitly distinguish itself from sibling tools like device_get or device_outages, so it lacks sibling differentiation.

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 about when to use this tool versus alternatives like device_get, devices_list, or device_outages. The description gives no context about typical use cases, 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the core safety profile is covered externally. The description adds no further behavioral context such as whether deletion cascades to ports, services, or historical data, but it does not contradict the annotations either.

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, direct sentence that front-loads the action and object. Every word earns its place, and there is no unnecessary elaboration for such a simple one-parameter tool.

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

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

Given the tool's low complexity, one required parameter, complete schema coverage, strong annotations, and an existing output schema, the description is sufficient for an agent to make a correct call. A minor gap is the absence of any note about side effects or irreversibility, though destructiveHint partially covers that.

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 already describes the only parameter, hostname, as 'Device hostname to delete', and schema coverage is 100%. The description's phrase 'by hostname' merely restates the schema rather than adding new meaning like format requirements, case sensitivity, or edge-case behavior.

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

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

The description states a specific verb ('Delete'), a definite resource ('a device from LibreNMS'), and the identifying key ('by hostname'). This makes the operation unmistakable and distinguishes it clearly from sibling delete tools that target other resource types such as rules, locations, or bills.

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

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

The description implies the use case: use this tool when you need to remove a device from LibreNMS by hostname. However, it does not explicitly name alternatives, say when not to use it, or mention any prerequisites such as the device needing to exist beforehand.

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

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

Annotations indicate the tool is not read-only and not idempotent, but the description adds no behavioral context beyond that. It does not disclose whether the trigger is asynchronous, what side effects occur (e.g., polling, ARP/SNMP discovery), or what happens for unknown/nonexistent hostnames.

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

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

A single, front-loaded sentence with no filler. Every word contributes to stating the action and target, which is the ideal level of brevity for a simple one-parameter operation.

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

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

Given a simple one-parameter schema and the presence of an output schema, the description is minimally adequate. However, it lacks context about what rediscovery entails, whether it returns immediately or runs asynchronously, and how errors are handled. These gaps could cause an agent to misuse or misinterpret the call despite the simple input.

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

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

Schema coverage is 100%, and the schema already documents hostname as 'Device hostname or ID'. The tool description adds no extra meaning regarding the parameter's format, resolution, or examples, so the baseline 3 applies.

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

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

The description states a specific action ('trigger') on a specific resource ('device rediscovery') in a named system (LibreNMS). 'Rediscovery' is a distinct operation from sibling tools like device_get or device_update, though it does not explicitly name an alternative.

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

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

No guidance is given on when to use this tool versus alternatives such as device_update, device_set_maintenance, or device_add. The description does not mention prerequisites, typical scenarios, or exclusions; usage must be inferred entirely from the tool name.

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

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

Annotations (readOnlyHint=false, idempotentHint=false, destructiveHint=false) already establish this as a non-idempotent write that is not destructive. The description adds essentially nothing beyond that — no mention of device-existence requirements, payload limits, side effects, or whether entries are appended. All-false annotations carry the behavioral burden and the description does not enrich them.

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

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

A single front-loaded sentence with zero filler. Every word adds meaning, and the size is proportionate to a two-parameter tool.

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

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

Although the output schema covers return values and the input schema documents parameters, the description is incomplete for a mutation tool: it does not state that the hostname must reference an existing device, how this relates to logs_eventlog, or what happens on repeated calls. An agent is left to infer operational context.

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

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

Schema description coverage is 100%, so the schema documents hostname and payload (including text/type/severity sub-fields). The description contributes no parameter information, so the baseline of 3 is appropriate; a small gap is that the severity range (1-5) direction is not clarified anywhere.

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

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

The description uses a specific verb ('Add') with a specific resource ('custom event log entry') and target ('a device'). The write polarity clearly separates it from read-oriented siblings like logs_eventlog, though it does not explicitly name an alternative.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., the device must already exist), and no conditions or exclusions. The only implied usage is the verb itself, which does not rise to real 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?

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds useful behavioral context by explaining that entries carry the learned port_id and that this is a device-wide perspective of switch connectivity, which is valuable beyond the annotations.

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

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

Two sentences accomplish everything: the first states the action and object, the second explains the key output detail and perspective. No filler or repetition of schema information appears.

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, annotations cover safety, the schema fully documents parameters, and an output schema exists, so the description does not need to explain return values. The only notable gap is lack of explicit routing to sibling tools, but this does not prevent 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 100%, so the parameters hostname, limit, and offset are already fully documented. The description does not add parameter-specific semantics, but it also does not need to because the schema carries that burden.

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

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

The description uses a specific verb ('List') and resource ('forwarding database (learned MAC addresses)') for a device, making the primary purpose clear. It adds 'device-wide view of what is plugged into a switch,' which hints at a distinction from per-port or lookup siblings, though it does not explicitly name them.

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

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

The description implies use when you need the device-wide FDB view, and it characterizes the result as learned MACs with port_id. However, it gives no explicit guidance about when to choose this over sibling tools like fdb_lookup or port_fdb, and it does not state exclusions or 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the read-only nature is covered. The description adds no further behavioral context such as error handling when a hostname is not found, authentication requirements, or response details, but it does not contradict the annotations.

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

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

The description is a single sentence that communicates the action, target, source, and lookup key with no filler. It is front-loaded and easy to parse.

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

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

For a single-parameter, read-only, idempotent lookup tool with an output schema and safety annotations, the description provides all essential operational context. The agent knows what input to supply and what kind of result to expect; output structure is delegated to the output schema.

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

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

The input schema already has 100% coverage for the single parameter, including a description of 'Device hostname'. The tool description only repeats the fact that lookup is by hostname and adds no format, validation, or 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 uses a specific verb ('Get'), a clear resource ('device details'), a source ('LibreNMS'), and a lookup key ('by hostname'). This differentiates it from sibling tools like devices_list (enumeration) and device_ports_get (specific port 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 phrase 'by hostname' implies this is the tool for fetching a single device's general details, but the description provides no explicit guidance about when not to use it or which sibling alternative to prefer for more specific data (e.g., ports, availability, VLANs). Usage context is implied, not stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds that the output is an image, which is useful, but it does not disclose output format, potential errors, or any rendering-specific behavior beyond that.

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

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

The description is a single, front-loaded sentence with no wasted words. Every token earns its place: it names the operation, the resource, and the output type.

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

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

The schema carries most parameter context, but there is no output schema and the description does not specify the return format beyond 'image'. It also lacks guidance on how to obtain valid graph_type values, though the schema does reference device_graphs_list.

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

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

Schema description coverage is 100%, so the schema fully documents all seven parameters including defaults and types. The description adds no parameter-level meaning, which is acceptable given the baseline of 3 for high 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 uses a specific verb ('Render'), a clear resource ('device-level graph'), and an explicit output type ('as an image'). This distinguishes it from sibling graph tools like bill_graph and port_graph, and from device_graphs_list which lists graph types rather than rendering them.

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

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

The description implies when to use this tool: when a device-level graph image is needed. However, it does not explicitly compare against alternatives such as port_graph, bill_graph, or device_graphs_list, and gives no guidance on when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the output is a set of allowed graph_type values, but it does not disclose additional behavioral traits such as error behavior or auth requirements. Given the annotations, 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?

Two sentences, both purposeful: the first states the core action, the second provides usage context and concrete examples. No redundant wording or unnecessary detail.

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

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

For a one-parameter read-only list tool with an output schema, this description is complete. It defines the per-device scope, explains the purpose (graph type discovery), and connects directly to the dependent tool device_graph. Nothing essential is missing.

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

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

The input schema documents hostname as 'Device hostname or device ID' with 100% schema description coverage. The description adds no extra meaning to the hostname parameter itself; the examples of graph_type values relate to the output, not the parameter. Baseline 3 applies.

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

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

The description states a specific verb ('List') and resource ('graph types available for a device'), and the second sentence clarifies that it is the discovery tool for valid values of device_graph's graph_type argument. This distinguishes it clearly from device_graph and other graph-related siblings like port_graph.

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

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

It explicitly says 'Use this to discover the values accepted by the graph_type argument of device_graph', giving the agent a precise condition for when to call this tool. Concrete examples ('device_icmp_perf', 'device_poller_perf') further aid 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?

Annotations already declare destructiveHint=true and readOnly=false, so the safety profile is covered. The description confirms a mutation ('Add') but adds no context about duplicate names, acknowledged side effects, or authorization requirements; this is adequate but not enriched beyond annotations.

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

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

The description is a single front-loaded sentence with no filler or repetition. It states the action and target immediately, earning a maximum structure score.

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

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

For a complex nested-payload tool, the schema fully documents fields, required conditionals, and examples, and an output schema exists for return values. The only notable gap is lack of explicit usage routing, but the overall package is sufficient 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 100% and the payload property schema contains detailed field descriptions, conditional requirements, and examples. The tool description itself adds no parameter-level meaning, so it relies on the schema, matching the baseline for high 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 states a clear verb ('Add') and a specific resource ('device group to LibreNMS'), making the primary action unambiguous. It does not explicitly contrast with sibling tools such as devicegroup_update or devicegroup_delete, so it falls short of full differentiation.

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

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

The description provides no guidance on when to use this tool instead of devicegroup_update, devicegroup_delete, or devicegroup_add_devices. 'Add a new' only weakly implies creation of new groups, so an agent must infer the usage context.

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

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

The annotations already declare readOnlyHint=false and destructiveHint=true, signaling mutation and potential destructiveness. The description does not add details about what exactly happens when devices are added, whether the operation overwrites existing members, or whether it is reversible. It adds no context beyond the annotations, so a mid-range score is appropriate; there is no contradiction between description and annotations.

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

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

A concise single sentence that states the action and resource clearly. It contains no filler or redundant information. It could perhaps mention the payload format or a sibling contrast, but it is appropriately sized for a simple mutation tool.

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

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

The schema fully documents both parameters, and annotations identify the operation as destructive yet not read-only. However, the description does not state anything about the behavior of adding devices, such as whether duplicates are handled, whether the list replaces or appends, or what the response contains despite an output schema existing. For a simple write operation with full schema coverage, this is adequate but not rich.

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 covers 100% of both parameters with descriptions, so the baseline is 3. The description itself adds no parameter semantics beyond what the schema already provides. The payload format is documented in the schema, so the description does not need to compensate.

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

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

The description clearly states the action and resource: 'Add devices to a device group in LibreNMS.' It identifies the verb (Add), the resource (device group), and the object (devices). It is distinguishable from siblings like devicegroup_remove_devices and devicegroup_add, though it does not explicitly differentiate itself from those siblings.

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

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

No guidance is provided on when to use this tool versus alternatives such as devicegroup_add, devicegroup_update, or devicegroup_remove_devices. The description gives no context about prerequisites, such as the need for an existing device group, or when adding devices is appropriate. The agent must rely on the tool name and schema.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, covering the key safety behaviors. The description itself adds no further behavioral context, such as cascade effects on group members or behavior when the group does not exist; the annotations carry the transparency burden.

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, direct sentence with no filler. It front-loads the action and resource, then narrows the identifier method, making it quick and easy for an agent to parse.

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

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

For a simple one-parameter delete operation, the description is complete, especially given the destructive and idempotent annotations plus the presence of an output schema. Nothing essential for selecting or invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, and the single 'name' parameter is already described as 'Device group name to delete'. The description's 'by name' wording reinforces the schema but adds no extra semantic detail, such as case sensitivity, required format, or uniqueness expectations.

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

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

The description states a specific verb ('Delete'), resource ('device group'), and identifier method ('by name'), clearly distinguishing it from sibling tools like device_delete or location_delete. It leaves no ambiguity about what action is performed.

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 intended use is implied by the description: use this when you need to delete a device group by name. However, it does not explicitly state when not to use it or mention alternatives, such as device_delete for devices or devicegroup_update for modifying a group.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, fully covering the safety profile. The description adds no behavioral context beyond the bare 'List' — it does not mention that full=true changes the return shape or that limit/offset control pagination, though those details live in the schema. With the bar lowered by annotations, the description still contributes nothing extra, so a modest score is warranted.

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

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

One sentence of eight words with zero waste, and the verb 'List' is front-loaded. There is nothing to trim, and the terseness is proportionate for a simple read operation.

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

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

The definition benefits from rich structured data: an output schema documents return values, annotations cover the safety profile, and the schema fully documents parameter semantics. The only notable gap is routing guidance between this and the large sibling set, especially devices_list and the devicegroup mutation tools. For a low-complexity read tool, this is largely complete.

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

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

Schema description coverage is 100%, with all four parameters (name, full, limit, offset) documented in the input schema, so the baseline 3 applies. The description itself adds no parameter detail, but none is needed since the schema carries the load. No enums or complex types require further explanation.

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

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

States a specific verb+resource: 'List devices in a device group from LibreNMS.' The scoping 'in a device group' clearly sets it apart from a generic device listing, and the verb 'List' is unambiguous. It does not explicitly name sibling alternatives like devices_list or devicegroup_add_devices, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention devices_list for unfiltered device queries, nor devicegroup_add_devices/remove_devices for membership modification. An agent must infer usage purely from the tool name and schema.

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

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

Annotations already declare destructiveHint=true, so the safety profile is known. The description adds the specific target of the destructive action (device memberships are removed) but does not disclose reversibility, side effects on missing IDs, or what happens to the group. This is modest added context above the annotations.

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

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

The description is a single efficient sentence that front-loads the action and resource. Every word contributes to the core purpose, with no filler or repetition.

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

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

The schema and annotations cover parameters, payload format, and destructive nature, and an output schema exists. The description is adequate but leaves usage-vs-alternatives and behavioral nuances unaddressed, making it minimally complete rather than fully self-sufficient.

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

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

Schema description coverage is 100%, with both parameters documented (name and payload format). The tool description itself adds no parameter detail, so per the high-coverage baseline a 3 is appropriate.

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

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

The description uses a specific verb ('Remove') and a clear resource ('devices from a device group') and scopes it to LibreNMS. This distinguishes it from siblings like devicegroup_add_devices and devicegroup_delete, so an agent can identify its role immediately.

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

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

The description provides no guidance on when to use this tool instead of alternatives. It does not mention devicegroup_add_devices, devicegroup_delete, or any conditions or preconditions, leaving the agent to infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=true. The description adds no additional behavioral context, such as what gets destroyed or overwritten, whether existing maintenance windows are replaced, or what side effects the maintenance mode has. With a destructive mutation, the description should provide more transparency beyond the bare action phrase.

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

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

The description is a single concise sentence that immediately identifies the tool's purpose. There is no redundant wording or repetition of the schema details.

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 destructive annotation and the existence of sibling maintenance tools, the description is too thin. It does not explain what 'set maintenance' means operationally, whether the window replaces existing maintenance, or how this differs from device-level or location-level maintenance. The payload schema covers parameter formats well, but the overal semantics and operational context are missing.

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

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

Schema description coverage is 100%, so the input schema already documents name and payload fields including formats, optionality, and defaults. The description itself adds no parameter semantics, but the baseline of 3 applies because the schema carries the full burden successfully.

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

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

The description states a specific action ('Set') on a specific resource ('device group') within LibreNMS, so an agent can tell it is a maintenance-window mutation for device groups. However, it does not explicitly distinguish it from the sibling tools device_set_maintenance or location_set_maintenance, so it misses some sibling differentiation.

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

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

There is no guidance on when to use this tool versus device_set_maintenance or location_set_maintenance. The description does not state prerequisites, such as needing an existing device group, nor whether this should be preferred for group-level maintenance. The agent is left to infer usage from the tool name and schema.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that this is a list operation against LibreNMS and returns a dict, but does not discuss pagination behavior despite the limit/offset parameters, nor any auth requirements. 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 short and front-loaded, stating the core purpose in the first sentence. The 'Returns: dict: The JSON response from the API' section is somewhat redundant and adds little value, but the overall structure remains efficient.

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

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

For a simple read-only list tool with an output schema, annotations, and fully documented pagination parameters, the description is mostly complete. It could explicitly warn that 'all' is constrained by the default limit and offset, but the schema already provides that information.

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

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

Schema description coverage is 100%, with clear descriptions for limit and offset already in the input schema. The tool description adds no additional parameter context. The baseline of 3 is appropriate because the schema carries the parameter documentation burden.

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

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

The description states a specific verb and resource: 'List all device groups from LibreNMS.' This clearly identifies the operation and differentiates it from sibling tools like devicegroup_add, devicegroup_update, and devicegroup_devices.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention that this is for listing all groups, while other tools handle creation, updates, deletion, or membership queries. An agent must infer usage from the name and schema.

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

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

Annotations already communicate destructive and non-read-only behavior, so the description's short 'Update' statement is acceptable. The payload schema separately implies patch-like semantics via 'Patchable fields,' but the description itself adds no additional behavioral context about what changes or side effects may occur. No contradiction with annotations.

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

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

The description is a single, front-loaded sentence with no filler. It is concise and to the point, though it could have used extra space to clarify usage context.

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

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

With a rich input schema and annotations, the description is minimally adequate, but it lacks guidance on prerequisites, how the update affects existing device assignments, or when this tool should be preferred over related devicegroup operations. The presence of an output schema means return values need not be covered.

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

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

Schema coverage is 100%, so the schema already documents both parameters, including the patchable fields inside the payload object. The tool description itself adds no parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Update a device group in LibreNMS.' It clearly distinguishes from sibling tools like devicegroup_add and devicegroup_delete, though it does not elaborate on what kinds of updates are supported within the description itself.

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

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

The description gives no guidance on when to use this tool versus alternatives such as devicegroup_add_devices, devicegroup_remove_devices, or devicegroup_set_maintenance. There are no explicit conditions, exclusions, or alternative routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral context such as pagination behavior or data scope, but it does not contradict the annotations.

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

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

The description is a single concise sentence with no filler, front-loading the action and resource. It is easy to scan and fully earns its place.

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

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

For a simple read-only tool with a complete input schema, an output schema, and safety annotations, the description is nearly sufficient. It is slightly incomplete in that it does not clarify how device_links relates to switching_links, but the output schema likely resolves much of the ambiguity.

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

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

Schema description coverage is 100%, so limit, offset, and hostname are already well documented in the schema. The description's phrase 'specific device' mildly reinforces hostname as the key parameter, but it adds no meaningful semantic value 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 states a specific action ('Get'), a resource ('network links'), and a scope ('for a specific device'), which is clear and actionable. However, it does not differentiate from sibling tools like switching_links, which may overlap in meaning, so it falls short of a perfect 5.

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

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

No guidance is provided about when to use this tool versus alternatives such as switching_links, device_ports, or ports_search. The description implies a use case for retrieving links for a device, but it gives no 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the point-in-time scope ('currently') but no additional behavioral detail such as response shape or edge cases, which is acceptable given the annotations and existing output schema.

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

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

The entire description is one focused, front-loaded sentence with no filler or redundant wording. Every word contributes to the tool's 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?

For a simple single-parameter status check with a complete input schema, read-only annotations, and an output schema present, the description is sufficiently complete. An agent has enough information to select and invoke it correctly.

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

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

The input schema has 100% description coverage for the single hostname parameter, describing it as 'Device hostname or ID'. The tool description does not add further parameter-level meaning, so the schema already carries the burden and the baseline score of 3 applies.

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

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

The description uses a specific verb ('Check') and resource ('device maintenance status'), clearly distinguishing this read-only status query from sibling tools like device_set_maintenance. The phrase 'currently in maintenance mode' makes the tool's exact function immediately understandable.

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 clearly implies this tool should be used when the agent needs to determine a device's maintenance state, rather than change it. It does not explicitly name an alternative such as device_set_maintenance for toggling maintenance mode, so it stops short of a top score, but the context is clear enough.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior. The description adds useful behavioral context: it shows authenticated endpoints per port, includes authentication method, and notes that VLAN assignment is shown only 'where the device reports it'—a meaningful caveat about data availability. No contradiction with annotations.

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

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

Two concise sentences with no filler. The primary action is front-loaded, and the follow-up sentence adds relevant output details. Every word contributes to 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?

For a read-only list operation with an output schema and well-documented parameters, the description covers what the tool returns and its device scope. It could have explicitly referenced a sibling like nac_list for broader context, but nothing essential is missing.

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

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

Schema coverage is 100%, with all three parameters (hostname, limit, offset) having descriptions. The tool description does not add parameter-specific meaning beyond stating the device scope and output contents, so the baseline of 3 applies.

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

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

The description states a specific verb and resource: 'List network access control (802.1X / MAB) sessions on a device.' It clearly scopes to a single device, distinguishing it from the sibling tool nac_list which likely covers sessions across multiple devices. The added detail about authenticated endpoints, authentication method, and VLAN makes the purpose unmistakable.

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

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

The description clearly indicates this tool is for listing NAC sessions on a specific device, giving the context of when to use it. However, it does not explicitly mention alternatives or when not to use it, such as pointing to nac_list for a global view, so it falls short of full exclusion 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds only the source system (LibreNMS) and offers no additional behavioral context such as pagination or filtering 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?

The description is a single, efficient sentence with no wasted words. It is appropriately concise for a simple read-only lookup tool.

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

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

For a straightforward read-only query with a required hostname parameter, an output schema, and full annotation coverage, the description is mostly complete. It could be improved by noting how outages are defined or when to prefer this over similar tools, but nothing essential to invoking it correctly is missing.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description does not add any meaning beyond the schema, which is acceptable per the baseline for full 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 states a specific verb and resource: 'Get device outages from LibreNMS.' It is clear about what the tool does, but it does not differentiate this from potentially related sibling tools such as device_availability or alerts_get.

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

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

There is no guidance on when to use this tool versus alternatives. No context is given about which scenarios call for device outages compared to other monitoring or alerting tools, and no exclusions are mentioned.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no extra behavioral context such as pagination behavior, default limits, or how columns filtering affects results, but it also does not contradict the annotations.

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

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

The description is a single compact sentence that leads with the verb and resource. There is no filler or redundant content, making it appropriately sized and 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?

The schema, annotations, and output schema cover most invocation needs, so a sparse description can be acceptable. However, the existence of a nearly identically named sibling (device_ports_get) and no clarification of scope leaves a material selection gap 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?

Schema description coverage is 100%, with all four parameters documented (hostname, limit, offset, columns). The phrase 'for a device' restates the hostname parameter and adds no additional semantic detail beyond what the schema already 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 states a clear action ('List') on a specific resource ('ports') scoped to a device from LibreNMS. It is unambiguous in what the tool does, but it does not differentiate from the similarly named sibling device_ports_get or related tools like ports_list.

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

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

No guidance is given on when to use this tool versus alternatives. The description does not mention device_ports_get, ports_list, or ports_search, nor any conditions that would select one over the other.

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

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

Annotations already declare readOnlyHint true, idempotentHint true, and destructiveHint false, so the safety profile is fully covered. The description adds no behavioral detail beyond the annotations, but it also does not contradict them; it is minimally acceptable given the annotation coverage.

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

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

A single, front-loaded sentence that states the operation, the resource, and the lookup key with no filler or repetition. Every word earns its place.

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

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

For a simple two-parameter read-only getter, the description is complete: the parameters are fully documented in the schema, the annotations cover safety, and an output schema exists to define return values. Nothing essential is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents hostname and ifname. The description reinforces that ifname is the interface name, but it does not add meaning beyond the schema—matching the baseline for high 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 uses a specific verb ('Get'), a clear resource ('port info'), and a precise scope ('for a device by interface name'). It is unambiguous on its own but does not explicitly differentiate itself from sibling tools like device_ports or port_get.

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

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

The phrase 'by interface name' implies the tool is used when you have both a device hostname and an interface name, but it gives no explicit when-to-use or when-not-to-use guidance and names no alternatives. The usage context is present but only implied.

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

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

The description adds no behavioral detail beyond what the annotations already declare. With destructiveHint=true and idempotentHint=true, the safety profile is known, but the description does not explain any side effects of renaming (e.g., impact on references, monitoring, or historical data), so it provides minimal value beyond the annotations.

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

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

A single, direct sentence that immediately communicates the operation. There is no redundant information or filler; the description earns its place and is easily parsed.

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 rename operation, the description is minimally adequate, especially with annotations covering destructive and idempotent behavior and an output schema present. However, it lacks any guidance on selection relative to device_update and does not mention potential side effects that would help an agent invoke it responsibly for a destructive operation.

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

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

Schema description coverage is 100%: both hostname and new_hostname have clear descriptions ('Current device hostname or ID' and 'New hostname for the device'). The tool description adds nothing beyond the schema, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Rename') and resource ('a device in LibreNMS'), making the tool's core function unambiguous. However, it does not explicitly differentiate from the sibling device_update, which could plausibly also change a device's hostname.

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 about when to use this tool versus alternatives like device_update or device_add. The description only states the action without any context about prerequisites, intended use cases, or conditions that would make another tool preferable.

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