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

With no annotations, the description carries the full burden, and it does disclose useful behavior beyond the schema: the transfer mechanism (HTTP download) and the destination (the backup dir). However, it omits permissions/auth needs, whether it overwrites existing backups, and any size/time constraints.

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

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

Two tight lines with the action front-loaded and the parameter values following. The abbreviated 'content:' fragment is slightly terse but wastes no words.

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

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

For a single-parameter tool with an output schema (so return values need no explanation), the description covers the action, destination, and valid input values. It stops short of documenting where the backup dir lives or auth requirements, but is otherwise sufficient.

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

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

Schema coverage is 0% and the single 'content' param has no enum in the schema, so the description's list 'running|startup|backup|flash_log|buffer_log|tech_support' is the only place the allowed values appear. It compensates for the coverage gap, though it does not explain what each value captures.

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

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

States a specific verb and resource: 'Download a backup over HTTP into the backup dir,' which is concrete and actionable. It does not differentiate itself from the closest siblings (sync_snapshot, sync_to_github, save_running_to_startup), which an agent might confuse with a backup operation.

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

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

There is no explicit when-to-use guidance, no prerequisites, and no named alternatives among the many sibling tools. The content list hints at optional modes but reads as an enumeration rather than usage direction.

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

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

With no annotations, the description carries the full burden; it usefully discloses that dry_run defaults to a preview and that applying auto-backups. It does not cover permissions, irreversibility, or error behavior for a mutation tool, so it is only partially transparent.

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

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

Two tight, front-loaded sentences with no filler; the core action comes first and the behavioral caveats follow. Slightly telegraphic wording ('auto-backup on apply') costs nothing but adds little polish.

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

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

An output schema exists so return values need not be described, and the preview/backup notes cover key behavior. But for a write tool with no annotations and undocumented parameters, more guidance on side effects and prerequisites would be needed for a complete definition.

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

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

Schema coverage is 0%, so description should compensate; it explains dry_run's preview meaning but says nothing about vlan_id range/constraints or name rules. It adds some value for one parameter only.

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

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

States a specific verb and resource ('Create a VLAN') that clearly distinguishes it from siblings like delete_vlan, list_vlans, and get_vlan_membership. However, it does not explicitly name or contrast with any alternative sibling, so it stops short of the top band.

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

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

Usage is implied by the verb and the dry_run preview note, but there is no explicit when-to-use versus alternatives guidance (e.g., when to use delete_vlan or set_port_vlan_membership instead). Adequate but with a clear gap.

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

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

No annotations, so the description carries the full behavioral burden. It discloses two important refusal conditions and that dry_run defaults to true and previews, which is meaningful safety context. It still omits auth requirements, reversibility, and exactly what dry_run=false commits.

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

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

Three short sentences, front-loaded with the core action and the most important constraint. Every sentence adds operational value; no filler.

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

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

For a destructive 2-param tool with no annotations, the description covers purpose, refusal preconditions, and dry-run default – enough to call safely. Output schema exists, so return values need not be explained. Missing permissions/reversibility details are minor gaps.

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

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

Schema coverage is 0%, so the description must compensate. It explains dry_run's default and preview behavior, and the refusal conditions constrain vlan_id (not 1, no member ports). However, it does not define vlan_id's type or range beyond the schema, leaving half the parameter space to inference.

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

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

States a specific verb 'Delete' and resource 'VLAN'. No sibling performs VLAN deletion (create_vlan, list_vlans, get_vlan_membership are distinct), so the purpose is unmistakable even without naming 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?

Explicitly states when the tool refuses to run (VLAN 1, VLANs with member ports), which is strong when-not guidance. It does not name an alternative workflow (e.g., removing member ports first), so it falls short of full when/alternatives guidance.

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

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

No annotations are provided, so the description carries full behavioral burden. It doesn't state that this is a read-only operation, whether it requires auth, what the global scope implies, or any side effects. The phrase 'global configuration' hints at scope but doesn't clarify behavior. LACP global config could be large; no mention of output format or size.

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, front-loaded, but it's a fragment that restates the name rather than stating an action. Not verbose, but it doesn't earn its place by adding information beyond the tool name.

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

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

With an output schema present, return values needn't be explained. However, with no annotations and a terse description, the definition is incomplete: it doesn't say the tool is a read, doesn't mention authentication or rate limits, and doesn't differentiate from siblings like get_stp_config or get_loopguard_config. For a config retrieval tool, this leaves gaps.

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?

Zero parameters, so baseline is 4. No parameter semantics to describe, and the description doesn't invent any. Schema coverage is 100% (trivially, since no params).

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

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

The description names a specific resource (Link Aggregation / LACP global configuration) but uses a bare noun phrase with no verb, so it doesn't state what the tool does. The 'get_' prefix implies retrieval, but the description itself doesn't say 'retrieve' or 'return'. It distinguishes from sibling config tools by resource name, but only weakly.

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 when-to-use guidance, no alternatives named, no conditions. The agent must infer from the name that this fetches LACP config rather than setting it. Sibling names like get_stp_config suggest a pattern, but the description doesn't help select this tool over others.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It says nothing about read-only nature, permissions, side effects, or result behavior, and merely labels the resource.

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

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

The description is extremely short but under-specified rather than concise. 'LLDP configuration.' omits the action and any useful framing, so the brevity does not earn 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?

Although an output schema exists and the tool is simple, the description still fails to state that this is a retrieval operation or what it returns in context. An agent has to infer the purpose almost entirely from the tool name.

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

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

The tool has zero parameters, so there is no parameter semantics for the description to explain. The schema itself is empty and fully self-explanatory; baseline for zero params is 4.

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

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

The description 'LLDP configuration' is a noun phrase that restates the tool's resource without stating an action. The name get_lldp_config implies retrieval, but the description itself does not add a verb or distinguish this getter from the numerous sibling get_*_config tools.

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

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

There is no guidance on when to use this tool, what it requires, or how it relates to sibling tools like get_running_config_text or get_system_info. The description provides no usage context at all.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing about behavior, permissions, or side effects. The 'get_' prefix weakly implies a read-only operation, which is the only behavioral signal present.

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 fragment is extremely short and front-loaded with no wasted words, but this is under-specification rather than genuine conciseness — there is simply almost no content to 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 zero-parameter read tool with an output schema already describing the return payload, the description covers the minimum: it names the resource and the protocol. It lacks any usage or behavioral context, but little more is strictly required to invoke it.

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

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

The tool takes zero parameters, so there is no parameter semantics to document; the baseline of 4 applies.

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

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

The description is a bare noun phrase that essentially restates the tool name, adding only the acronym expansion '(RLDP)'. It conveys no verb, no scope, and nothing that distinguishes it from the many other get_*_config siblings beyond the noun 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?

There is no guidance on when to call this versus siblings such as get_lldp_config, get_lag_config, or get_stp_config. An agent must infer the use case entirely from the name.

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

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

With no annotations, the description carries the full behavioral burden. It notes that entries are 'learned' (implying dynamic entries), but does not disclose read-only nature, required permissions, pagination, or whether static entries are included.

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

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

The single sentence is front-loaded with the resource and contains no redundant or filler language. It is appropriately sized for the tool's simplicity.

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

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

An output schema exists, so return values need not be described. For a simple read tool with one optional parameter, the description covers the essential purpose and filter, though it omits read-only confirmation and any authentication 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 0%, so the description must compensate. It explains that vlan_id acts as an optional VLAN filter, adding semantic meaning beyond the bare schema, but does not provide accepted value formats or ranges for the parameter.

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

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

The description names the specific resource (learned MAC addresses) and its optional scope filter (VLAN), making the tool's output clear. However, it doesn't explicitly differentiate from sibling tools or state a verb, relying on the name 'get_mac_table' for the action.

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

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

It implies usage by stating the optional VLAN filter, but gives no guidance on when to use this versus other inspection tools or when the VLAN filter is appropriate. No alternatives or 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about read-only semantics, permissions, or scope. It does not even explicitly confirm that this is a read operation rather than a configuration modifier. Only the return values are covered, and that is via the output schema rather than 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?

It is a single front-loaded fragment with no waste, which satisfies conciseness. However, the brevity comes at the cost of substance rather than being efficient expression of meaningful content.

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

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

For a zero-parameter getter with an output schema, the description needs only to identify the resource and confirm read intent, and it half-does that. It leaves the agent without any sense of what the mirroring config contains or how it relates to sibling config tools, but the low complexity keeps this from being a severe gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. Schema description coverage is 100% and the empty properties object is unambiguous.

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 is a noun phrase that essentially restates the tool name: 'get_mirror_config' → 'Port mirroring configuration.' It adds only the qualifier 'port' and does not state a verb or retrieval intent. An agent can infer it reads configuration, but that inference comes from the name, not the description.

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 when-to-use guidance, no prerequisites, and no mention of alternatives among the many sibling config getters (get_lag_config, get_loopguard_config, get_stp_config, etc.). The intended context is left entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read but never states that it is non-mutating, requires no special permissions, or has any rate/scoping behavior. It only discloses the category of counter data returned, which is thin for a tool with zero annotation coverage.

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

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

It is a single short fragment with no filler and the key information is front-loaded. However, the size reflects under-specification rather than disciplined conciseness, since several needed details are simply absent.

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

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

An output schema exists, so return values need not be explained, and this is a simple one-parameter read tool. Still, with no annotations and an undocumented required parameter, the definition leaves the agent guessing about invocation details that the description should have 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?

The single 'port' parameter has 0% schema description coverage, and the description only hints at it with 'per-port'. It does not say what form the port identifier takes (index, name, interface number) or whether it refers to a physical port versus a LAG, leaving the one required parameter under-specified.

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 noun phrase names a specific resource (per-port MIB counters) and enumerates the counter categories (octets, packets, discards, errors), which is enough to distinguish it from siblings like get_port_status. It lacks an explicit verb, but the 'get_' prefix and the resource naming make the intent unambiguous.

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

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

No indication of when to use this versus the many sibling read tools (get_port_status, get_mac_table, get_pvids, etc.). Nothing tells the agent what condition selects counter retrieval over status retrieval, and no prerequisites are stated.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It discloses nothing about read-only behavior, authentication requirements, rate limits, or any other trait; it is completely silent on 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?

It is a short sentence fragment with no wasted words, but it is under-specified rather than concise. There is no verb, action, or purpose front-loaded, so it fails to inform the agent.

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 tool is simple with no parameters and has an output schema, the absence of annotations plus a purely nominal description leaves an agent unable to distinguish this getter from others or understand its usage context.

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

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

The tool has zero parameters, so per the rubric the baseline is 4. The description does not need to add parameter meaning, and none is expected.

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 'Port Security configuration.' is a noun phrase that restates the resource but does not state the action (e.g., retrieve/read). It relies entirely on the tool name 'get_port_security_config' to convey that it is a getter, and it does not differentiate itself from sibling getters like get_stp_config beyond the resource name.

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, prerequisites, or context of use. The description contains no when-to-use or when-not-to-use information despite many sibling configuration getters.

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

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

No annotations are provided, so the description carries the full burden. It discloses what is returned (link state, speed, duplex), which signals a safe read operation, but says nothing about required permissions, scope (all ports vs a single port), or behavior on a down/absent port.

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; the resource comes first and the returned attributes follow compactly in parentheses.

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

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

With an output schema present the description need not document return values, and with zero parameters and no annotations the remaining burden is small. A brief note on scope (all ports) and permissions would have made 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?

The tool takes zero parameters, so the baseline is 4. The description adds no parameter detail, which is appropriate here, and only clarifies what the per-port status consists of.

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 ('Get') and resource ('per-port link status') and enumerates the returned attributes (up/down, speed, duplex). This distinguishes it in practice from read siblings like get_port_counters or get_system_info, though it never names an alternative explicitly.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites, and no pointer to related tools such as get_port_counters. 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?

No annotations are supplied, so the description carries the behavioral burden, but as a zero-argument read getter there is little to disclose. It does not mention whether ALL ports are always returned (e.g. ports without a PVID), which is the one behavioral detail an agent might want.

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 waste, expanding the acronym inline. Nothing extraneous and nothing important deferred.

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

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

With no parameters and an output schema present, the description only needs to convey scope and identity, which it does. The main residual gap is the absence of any sibling comparison, but return-value detail is rightly left 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 tool takes no parameters, so there is nothing to document; the baseline for a zero-parameter schema is 4. The description correctly implies the breadth of the result rather than a filtered lookup.

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 (get) and resource (PVID for every port), and expands the acronym so an agent knows exactly what comes back. It does not differentiate itself from read siblings such as get_vlan_membership, which also expose VLAN-related port data, so it falls short of a 5.

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

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

There is no guidance on when to call this versus get_vlan_membership or list_vlans, nor any prerequisite noted. Usage is only implied by the read-oriented 'Get' verb.

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

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

No annotations are provided, so the description carries full behavioral disclosure burden. It only states that it fetches config as text, without mentioning read-only nature, permissions required, rate limits, or any side effects. This is a minimal disclosure for an unannotated tool.

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

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

A single, front-loaded sentence with no wasted words. The purpose and implied context are delivered immediately.

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

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

Given zero parameters and an output schema, the description is nearly complete for an agent to invoke correctly. It lacks any mention of operational context (e.g., read-only safety), but the output schema covers return values, and the simplicity of the tool keeps the gap minor.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description does not need to add parameter meaning and correctly does not.

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

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

The description names a specific verb ('Fetch'), resource ('running configuration'), and format ('as text'), which distinguishes it from sibling get_*_config tools that retrieve narrower config sections. However, it does not explicitly differentiate itself from backup_config or save_running_to_startup, leaving some ambiguity about its unique role.

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

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

The parenthetical '(diffing/auditing)' implies intended use, but provides no explicit when-to-use or when-not-to-use guidance, nor does it name alternatives for configuration retrieval. The agent must infer context from the purpose 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses no read-only nature, permissions, side effects, or retrieval behavior. It adds nothing beyond the resource label.

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 noun fragment. It is short but under-specified rather than well-structured, omitting the action and any useful context. It is not verbose, but it is too sparse to earn a higher conciseness 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 parameterless read tool with an output schema, the resource label may be minimally sufficient to identify what is returned. However, the description still omits the retrieval action and any usage context, leaving gaps that the schema and annotations do not fill.

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

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

The tool has zero parameters, so the baseline is 4. There are no parameter semantics to explain, and the empty schema is fully self-describing.

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

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

The description names the resource (Spanning Tree global configuration) but omits a verb, so it does not explicitly state what the tool does. The tool name supplies the action, but the description alone is a noun phrase. It does distinguish the resource from siblings like loopguard or LLDP configuration.

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 when-to-use, prerequisites, or alternatives are given. The agent receives no routing guidance among the many get_*_config siblings.

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

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

No annotations are provided, so the description must carry the behavioral burden. 'Syslog configuration.' does not disclose whether the operation is read-only, what data is returned (though an output schema exists), or any side effects. The output schema may cover return values, but the description adds no behavioral context.

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

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

The description is extremely concise—just two words—but it is front-loaded and contains no wasted words. However, it is arguably too terse, lacking substance to be fully helpful.

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 complexity of a configuration retrieval tool and the presence of an output schema, the description is insufficient. It does not mention what syslog configuration entails (e.g., servers, logging levels) or how it relates to siblings. An agent would need to infer that it returns the syslog settings without any confirmation.

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

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

There are zero parameters, so per the rules, the baseline is 4. The description correctly indicates no inputs are needed, though it does not explicitly state this.

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

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

The description 'Syslog configuration.' restates the tool name (get_syslog_config) without adding a verb or scope, making it a near-tautology. It does not distinguish itself from its sibling configuration getter tools like get_lag_config or get_lldp_config. The purpose is implied but not explicitly stated.

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

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

There is no guidance on when to use this tool versus alternatives, nor any context about prerequisites or expected outcomes. An agent could infer it retrieves syslog settings, but the description provides no explicit usage instructions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a safe read via 'Get' and lists the returned data, but says nothing about permissions, rate limits, or device-connection prerequisites. The existence of an output schema covers the response shape, keeping this at an adequate but unrich 3.

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; the verb and resource come first and the parenthetical field list adds useful scope without waste.

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

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

For a zero-param, zero-annotation read tool with a full output schema, the description is sufficient: the agent knows what is fetched and that it needs no arguments. More context on device connectivity or failure modes would push it higher, 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; per the baseline for parameterless tools this scores 4. The field list serves as informal output documentation rather than 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 gives a specific verb ('Get') and resource ('switch system information') and enumerates the returned fields (model, firmware, uptime, IP), so the agent knows exactly what this tool retrieves. It does not explicitly contrast with the sibling set_system_info, but the read-only framing makes the distinction inferable.

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

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

There is no explicit when-to-use or when-not-to-use statement. Because this is a zero-parameter read of a well-known resource, the usage context is implied rather than stated, which lands at the minimum-viable level.

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

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

With no annotations provided, the description carries the full burden, but 'Get' plus the enumerated per-port states makes the read-only nature and returned content fairly clear. It does not disclose permission requirements, whether the VLAN must already exist, or behavior when vlan_id is omitted (schema default 1) — modest gaps for a simple getter.

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 naming the verb, the protocol scope, and the returned categories. Nothing wasted, no filler.

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

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

An output schema exists, so return-value documentation is not required, and the description correctly focuses on scope and content. For a one-parameter read tool this is nearly sufficient; only the absence of any when-to-use guidance and of parameter/dependency detail keeps it short of complete.

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

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

Schema coverage is 0% for the single vlan_id parameter, and the description only implies it via 'for a VLAN'. It communicates that membership is scoped to one VLAN but adds no format, range, or default behavior beyond what the schema's bare 'Vlan Id' title offers.

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 ('Get 802.1Q VLAN port membership for a VLAN') and enumerates the membership categories returned (tagged/untagged/forbidden/excluded). It is clearly distinguishable from the write sibling set_port_vlan_membership, though it does not explicitly contrast with list_vlans.

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 statement of when to use this tool versus alternatives. The obvious pairing with set_port_vlan_membership (read before write) is left for the agent to infer, and there is no mention of prerequisites or required context beyond the implicit VLAN scoping.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List all' implies a read-only, non-mutating operation, but the description does not confirm this, nor does it mention scope limits, permissions, or pagination for large VLAN tables.

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 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?

With zero parameters and an output schema present, the description need not explain return values. It adequately states what is listed, though the absence of annotations means the operation's read-only nature is only implied rather than confirmed.

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

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

The tool takes zero parameters, so there is no parameter semantics to convey; the baseline for a parameterless tool is 4. The description correctly implies the call is unconditional and unscoped.

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 (List) and resource (VLANs) with scope (all configured on the switch), so the agent knows exactly what it retrieves. It does not, however, distinguish itself from the sibling get_vlan_membership, which an agent might reasonably confuse it with.

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 versus get_vlan_membership, create_vlan, delete_vlan, or get_pvids. There is no context, no exclusions, and no 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?

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses that unsaved changes are discarded, that management access drops for ~1 min, that a config backup is taken pre-emptively, and that a confirmation token is required. It stops short of stating permission/auth requirements or the exact response shape, keeping it out of the top score.

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 compact sentences, front-loaded with the operation and its impact, then the confirmation requirement, then the safety net. Every clause adds decision-relevant information with no filler.

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

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

For a single-parameter destructive tool with an output schema already present, the description covers the impact, the required confirmation literal, and the automatic backup, which is enough to call it correctly. Missing only permission/auth expectations, which no structured field supplies.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by supplying the exact literal required for the only parameter (ack='REBOOT'), which the schema does not convey. Note a minor tension: the description says ack is required, while the schema lists zero required parameters and defaults ack to an empty string.

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 (reboot) on a specific resource (the switch), and no sibling tool offers anything comparable — the rest are config getters/setters. The parenthetical clarifies the exact effect of the operation, so an agent can distinguish it instantly.

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 strong context for deciding (management drops ~1 min, unsaved changes are discarded), which implicitly tells the agent this is a last-resort disruptive action. However, it never states when to prefer this over alternatives like save_running_to_startup or backup_config, nor any prerequisite precondition. 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?

No annotations are provided, so the description carries the full behavioral burden. It states the copy but omits important traits: whether the startup config is overwritten, whether the change is reversible, whether confirmation is required, and what side effects occur. It adds little beyond the tool name.

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

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

One short, front-loaded sentence with no redundant or filler content. It states the action and both endpoints directly.

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 absence of parameters and the presence of an output schema reduce the information burden, but the description still omits safety and usage context for a config-persistence operation. An agent can invoke it correctly, yet may not know when it is appropriate relative to 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?

The tool has zero parameters, so the empty schema fully covers the input surface. The baseline of 4 applies; there are no parameter details for the description to clarify or compensate for.

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

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

States a specific verb (copy) and the exact resource pair (running configuration to startup configuration), making the operation unambiguous. However, it does not distinguish this from sibling tools like backup_config or sync_snapshot, which an agent might reasonably consider.

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 when-to-use guidance, prerequisites, or alternative routing is provided. The description never explains when an agent should persist the running config rather than calling backup_config, sync_snapshot, or sync_to_github.

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

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

With no annotations, the description discloses key behavior: protected ports are refused, disabling a link-Up port is refused, and dry_run previews current vs target. It still omits permission, persistence, and error semantics, but covers the most important safety constraints.

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

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

Three compact sentences, front-loaded with the core action and allowed values, then safety constraints and dry-run behavior. No filler.

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

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

For a 7-parameter mutation tool with no annotations and no schema descriptions, the description covers core behavior but not all parameters or persistence and error details. Output schema exists, so return format need not be explained.

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

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

Schema description coverage is 0%, so the description must compensate. It provides critical allowed values for speed and duplex and explains dry_run's effect, but leaves port, enabled, description, and flow_control without added 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?

States a specific verb, configure, and resource, port, with the main settings speed and duplex listed. It does not explicitly contrast with sibling setters like set_port_vlan_membership or set_pvid, so sibling differentiation is incomplete.

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 dry_run default and refusal conditions imply preview-then-apply usage, but the description does not say when to choose this tool over alternative port or VLAN configuration tools. It also does not mention prerequisites such as fetching status first.

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

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

With no annotations, the description carries the full burden and does well: it discloses that protected ports are refused, that state is auto-backed-up before applying, that running config is saved to startup on success, and that dry_run defaults to preview. It omits permission/auth requirements and whether failures roll back, but the mutation behavior is unusually well disclosed.

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

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

Front-loaded with the core action, then constraints and side effects in supporting sentences. Compact and mostly waste-free, though the mode enum parenthetical and the line-broken sentences are slightly awkward.

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

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

For a mutation tool with no annotations, this covers side effects (backup, startup save), refusals, and the preview flag, which is what an agent needs before invoking. An output schema exists so return values need not be described. Only auth/permission prerequisites 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 coverage is 0%, so the description must compensate. It usefully supplies the mode enum values (absent from the schema) and the dry_run default semantics, but leaves ports (integer format/port numbering) and vlan_id entirely unexplained.

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

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

States a specific verb (Set) and resource (port VLAN membership) and enumerates the mode values, which lets an agent distinguish it from set_pvid and set_port_config in the sibling list. The purpose is unambiguous.

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

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

It supplies the mode options and the protected-port exclusion, which is implied usage guidance, but it never states when to use this tool instead of set_pvid or set_port_config. No explicit when/when-not routing is given.

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

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

With no annotations, the description carries the full behavioral burden and delivers meaningful context: protected ports 1 and 4 are refused, and dry_run=true previews without applying. This usefully signals a mutating tool with a safe preview path, though auth/permission and success semantics are not covered.

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

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

Three short, front-loaded sentences with zero filler. The core action leads, with constraints and the preview flag following in order of importance.

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 mutating setter with an output schema (so return values needn't be described), the description covers the key behavioral facts an agent needs. Only minor gaps remain, such as permission requirements and post-success behavior.

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

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

Schema coverage is 0%, so the description must compensate. It clearly explains dry_run's default preview behavior, and 'port'/'pvid' are fairly self-evident, but it adds no detail on PVID value format/range or port numbering, leaving partial compensation for the coverage gap.

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

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

States a specific verb+resource ('Set a port's PVID') that an agent can distinguish from siblings like set_port_vlan_membership or set_port_config. The scope is unambiguous, though it doesn't explicitly name how it relates to 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?

The description explains constraints (protected ports refused) and dry_run semantics, but gives no guidance on when to use this tool versus alternatives such as set_port_vlan_membership. It assumes the agent already knows it needs to change a PVID.

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

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

With no annotations, the description carries the full burden; it does disclose the dry-run preview behavior and its default, which is valuable for a mutation tool. However it says nothing about persistence, required permissions, or side effects of a real (dry_run=false) write.

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 terse sentences, front-loaded on the action with the safety-relevant dry-run default appended. No wasted words, though it is arguably too sparse for a 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?

An output schema exists so return values need no explanation, and all four params are accounted for. Still, a write tool with no annotations should say more about prerequisites and the effect of committing changes.

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

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

Schema description coverage is 0%, so the description must compensate, and it names all three settable fields (name, location, contact) plus explains dry_run's semantics and default. That covers the full parameter set, though it adds no format or validation detail.

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 ('Set') and resource ('system name/location/contact'), making it easy to pair with the sibling get_system_info. It stops short of explicitly differentiating from read-side siblings, but purpose is unambiguous.

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

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

The note that dry_run=true is the default and previews gives implied guidance on safe invocation, but there is no explicit statement of when to use this tool versus alternatives or what prerequisites apply.

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

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

With no annotations, the description carries the burden and does well: it discloses the output location (ZYXEL_SYNC_DIR), the concrete set of files produced, that the running config is scrubbed, and that no git push occurs. It does not state whether existing files are overwritten, whether the write can be destructive, or what permissions are 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?

Two sentences, front-loaded with the action and destination, followed by the one behavioral caveat that matters most for tool selection. No filler.

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

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

An output schema exists, so return-value explanation is unnecessary, and the description covers destination, contents, and the git boundary. The remaining gap is edge-case behavior (overwrite semantics, failure when ZYXEL_SYNC_DIR is unset) in a zero-annotation, write-performing tool.

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

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

The tool takes zero parameters, so the baseline is 4. The description does add value by explaining that the destination comes from the ZYXEL_SYNC_DIR environment variable rather than an argument, which is the only 'parameter-like' input.

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 (Write) and artifact (a rebuild-ready snapshot) and enumerates exactly what the snapshot contains: scrubbed running config, JSON dumps of VLANs/ports/MACs/LLDP, MAC-keyed inventory, topology README. It also explicitly negates the git push, which cleanly separates it from the sync_to_github sibling.

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

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

The final sentence 'Does NOT push to git' is an implicit routing cue toward sync_to_github, and the mention of ZYXEL_SYNC_DIR establishes the precondition for use. There is no explicit 'use this when...' statement or statement of what happens if the env var is unset, so it falls just short of a 5.

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

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

With no annotations, the description carries the full burden. It does disclose that this is a mutating, remote-publishing operation and that configuration has no default (so a misconfigured call will fail). It omits auth requirements, whether a branch is created, and any reversibility/force-push semantics.

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

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

Three short sentences, front-loaded with the action and followed by the configuration sourcing. No filler, though the second sentence is split rather awkwardly across lines.

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

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

An output schema exists, so return values need not be described. For a mutation tool with no annotations, the description covers the config-sourcing prerequisite but leaves auth, branch behavior, and failure semantics unstated – adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It addresses only `remote` (and partially, via the env-var fallback) while `branch` and `message` are left entirely undocumented in both schema and prose, leaving two of three parameters semantically undefined.

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 effect chain – snapshot, commit, push to the operator's own repository – with a specific resource (GitHub repo). It does not, however, distinguish itself from the sibling sync_snapshot, which an agent might reasonably confuse it with.

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 explains the prerequisites for use (target from `remote`/ZYXEL_SYNC_REMOTE, directory from ZYXEL_SYNC_DIR, no built-in defaults), which is genuinely useful context. But it never says when to pick this over alternatives such as sync_snapshot or backup_config, so usage is only implied.

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