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

The readOnlyHint annotation already establishes that this is a safe read, and the [READ] tag is consistent with it. The description does add one genuine behavioral detail beyond annotations: unknown serials are reported as null rather than raising an error. It says nothing about what happens when the zone is missing or the secondary is unreachable.

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 short sentence with the read-only marker front-loaded and no filler. The [READ] tag is somewhat redundant with the annotation, and 'unknown stays null' is terse to the point of being cryptic.

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 three-parameter comparison tool with no output schema and zero schema descriptions, the definition is too thin. It does not explain which parameter denotes the primary, how the comparison result is expressed, or what a null versus a mismatch means to the caller.

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 carry all parameter meaning, and it does not. It never explains what 'zone', 'secondary', or especially 'target' (nullable, default null) refer to, leaving the primary/secondary mapping ambiguous.

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: compare primary and secondary SOA serials. An agent can distinguish this from mutation siblings like bind_retransfer_zone or bind_reload_zone, though it does not explicitly contrast with diagnostic siblings such as bind_zone_status or bind_show_zone.

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

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

The [READ] prefix and the word 'compare' imply the use case (checking whether a zone's serials match before a transfer), but no explicit when-to-use or when-not guidance is given. No alternative sibling is named, so the agent must infer the routing decision.

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, so safety is covered structurally. The description adds genuine context by naming named-checkconf -z, which signals that zone files are actually loaded and parsed rather than just syntax-checked, and implies no mutation or reload occurs. It does not state whether errors are surfaced as findings or thrown, so the transparency gain is moderate.

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, tag front-loaded, verb and resource immediately visible, and the concrete command appended as supporting detail. 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 validation tool with no output schema, the description explains what is checked and how, but leaves two things an agent needs: the meaning of 'target' and the shape of the result (pass/fail plus error list versus a raw command exit). Adequate but not complete.

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

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

Schema description coverage is 0% and the description never mentions the single 'target' parameter. An agent cannot tell from either source whether 'target' is a config file path, a directory, a server, or a zone name, nor what the null default means. With only one optional parameter this is a real gap rather than a minor one.

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: 'Validate BIND config and loaded zone files', and names the underlying mechanism (named-checkconf -z), which makes clear this is a static validation pass rather than a live query. It is distinguishable from most siblings such as bind_status or bind_query, though it does not explicitly differentiate itself from the closer bind_diagnose_zone or bind_compare_soa.

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 or when-not-to-use guidance is given. The agent is not told whether to run this before bind_reload_zone, or how it relates to bind_diagnose_zone. The '[READ]' tag and the word 'Validate' only imply usage; nothing steers selection among 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?

readOnlyHint=true already tells the agent this is a safe read, and the description adds that multiple probes are combined and only failures are reported. Beyond that it says nothing about latency (five probes could be slow), whether probes hit live servers, or what happens when a probe errors rather than fails. For a multi-step diagnostic this is thin.

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 the [READ] marker up front and zero filler. It is efficient, though the semicolon-clause format leaves the most important detail, what a report actually contains, compressed into three 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?

With no output schema and two undocumented parameters, the description should explain the shape of the failure report and how 'target' changes behavior; it does neither. An agent knows roughly what the tool is for but not how to call it correctly or what it will get back.

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 carries the full burden and adds nothing: it never explains whether 'zone' expects a fully qualified name with trailing dot or a view-qualified form, nor what 'target' means (a specific server to direct probes at versus the default). Both parameters are undocumented in both places.

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 and resource: it correlates named, config, zone, SOA and DNSSEC probes and reports failures. That distinguishes it from single-probe siblings such as bind_config_check, bind_compare_soa, and bind_dnssec_validation, though it does not name those siblings 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?

Usage is only implied: the list of probes it aggregates suggests this is the combined-diagnosis entry point rather than one of the single-probe siblings. There is no explicit when-to-use statement, no guidance on when a single probe would suffice, and no prerequisites such as the need for a resolvable zone.

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?

readOnlyHint=true already declares the safety profile, so the '[READ]' prefix adds nothing. What the description does add is the 'using rndc' mechanism note, which tells the agent this reaches the server via the BIND control channel and therefore needs a configured rndc session, but it says nothing about failure behavior when rndc is unavailable or about what the setting looks like when returned.

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

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

One short, front-loaded sentence with no filler and the read-only intent first. It is efficient, though the terseness is partly the cause of the missing parameter and return-value context rather than a virtue of disciplined editing.

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

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

This is a simple read-only status tool and readOnlyHint covers the safety dimension, so the description need not explain return values in depth. However, with an undocumented 'target' parameter and no output schema, the definition leaves the agent guessing on the one input it must supply.

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 is one optional 'target' parameter with 0% schema description coverage and a null default, and the description never mentions it. The agent cannot tell from the definition whether 'target' is a server host, a view, or an rndc endpoint, so it must guess how to invoke the tool with or without it.

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 plus resource ('Check current DNSSEC validation setting') and names the mechanism ('using rndc'), so the agent knows this is a status query rather than a mutation. It does not distinguish itself from near-siblings like bind_dnssec_zone_status or bind_security_roots, which is the main thing keeping it from 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 '[READ]' tag and 'Check current' wording imply a query-only operation, but there is no explicit when-to-use, when-not-to-use, or pointer to an alternative tool. Nothing tells the agent whether to prefer this over bind_dnssec_zone_status when investigating DNSSEC problems.

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 readOnlyHint annotation already declares the safety profile, so the '[READ]' prefix and 'Show' add no new information. Beyond that, the description says nothing behavioral: it doesn't explain the meaning of 'target', what happens for an unsigned or DNSSEC-unaware zone, or whether it queries a live server or local configuration.

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 short sentence that is front-loaded with the key action and resource. The '[READ]' tag is redundant given the readOnlyHint annotation, but the sentence itself contains no filler or awkward 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 tool with no output schema and no documented parameters, the description leaves the agent without enough to call it confidently or interpret results. It doesn't define what statuses are reported, what 'target' does, or how the output is structured.

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 for both parameters. It only loosely implies the required 'zone' argument ('for one zone') and gives no explanation at all for the optional 'target' parameter, whose purpose (server, view, or credential context) is completely ambiguous.

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 and resource: 'Show DNSSEC signing status for one zone.' An agent can tell it reports DNSSEC signing state rather than performing a mutation or a general zone lookup. However, it does not distinguish itself from closely named siblings such as bind_signing_status, bind_zone_status, or bind_managed_keys_status.

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 the many sibling status tools (bind_signing_status, bind_zone_status, bind_managed_keys_status, bind_dnssec_validation). The description only implies a narrow use case by naming DNSSEC signing status; no prerequisites or exclusions are given.

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

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

The annotations already declare readOnlyHint=true, and the description adds the useful domain context that results are servers/domains currently limited by recursive fetch caps. It does not describe output format or how the optional target parameter affects results, so it goes beyond annotations but not richly.

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 text. The leading "[READ]" tag is redundant with the readOnlyHint annotation, which is a minor inefficiency.

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 no output schema, the description is mostly complete in stating what is listed. However, it leaves the only parameter completely unexplained, which is a meaningful gap for correct invocation.

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

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

Schema description coverage is 0% and the single optional "target" parameter is not mentioned at all in the description. An agent cannot tell whether target is a server, a domain, or a filter from either the schema or the description.

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 ("Show") and resource ("servers and domains currently limited by recursive fetch caps"), making the tool's purpose clear. It does not explicitly differentiate this from sibling status or diagnostic tools, 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 use this tool versus related siblings such as bind_status or bind_config_check, nor any when-not conditions. Only an implied use case (inspecting fetch caps) is present.

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 "[WRITE]" tag and the irreversibility warning largely restate structured data. The description does add specificity about what is destroyed (one cached DNS name), but omits the existence of a dry_run safety path and any permission or target-scoping requirements.

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

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

A single sentence with the operation class tag front-loaded, then the action, scope, and consequence. No filler, and the destructive warning is placed where it will be read before invocation.

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 three-parameter mutation with no output schema and zero schema documentation, the description leaves the agent without the information needed to invoke it safely or correctly. Specifically, `target` and `dry_run` are undocumented anywhere in the 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 description coverage is 0%, so the description must carry parameter meaning, yet it only implies the required `name`. It says nothing about `target` (presumably which server/view to flush) or `dry_run`, which is the most safety-relevant parameter for a destructive operation.

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

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

"Flush one DNS name from cache" gives a specific verb (flush), resource (DNS cache entry), and scope (one name), which is unambiguous and clearly distinct from the zone/status-oriented sibling tools. It stops short of explicitly contrasting itself with any sibling, so it lands at a clear-but-not-exemplary 4.

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 (BIND server/target selection), and no mention of alternatives such as re-querying or reloading a zone. The warning about irreversibility hints at caution but does not tell an agent when this tool is the right choice.

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?

readOnlyHint=true already tells the agent this is a safe read, and the '[READ]' tag merely repeats that. The description adds no behavioral context beyond the annotation: no scope of the query, no notion of which server or view is inspected, no indication of output shape or whether an unconfigured trust-key set yields empty results.

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. It is lean rather than padded, though the space saved is not reinvested in any of the missing 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?

This is a simple read-only status tool with one optional parameter and no output schema, so the description's brevity is partly defensible. Still, the meaning of 'target' and the distinction from the other DNSSEC/security-root siblings are left entirely unexplained.

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

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

Schema description coverage is 0% and the single optional 'target' parameter is undocumented in both schema and description. The agent cannot tell whether 'target' means a server, a view, a zone, or a key name, nor what the null default implies, so the description fails to compensate 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 ('Show') and a specific resource ('BIND managed DNSSEC trust-key status'), which is enough to know roughly what comes back. It does not differentiate itself from close siblings such as bind_dnssec_zone_status, bind_security_roots, or bind_dnssec_validation, so an agent must guess which one surfaces managed-key trust state.

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 preconditions, and no mention of alternatives. The '[READ]' prefix only signals non-mutation, which the annotations already declare, so nothing routes the agent between this and the several other DNSSEC-status siblings.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=true, so the "[WRITE]" prefix adds nothing. The clause "downstream refresh remains unknown" is genuine added context: it warns the agent that success does not guarantee secondaries update. However, nothing is said about permissions, side effects on live DNS traffic, or what the response contains.

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 with the operation front-loaded and the caveat attached, with no filler. It is arguably too terse rather than too long, but every phrase present 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 destructive, non-idempotent three-parameter mutation with no output schema and no annotation-free coverage of parameters, the description is thin. It conveys purpose and one caveat but leaves the agent without guidance on target selection, dry_run usage, or expected results.

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 not. The required "zone" is only obliquely implied, while "target" (which changes who receives the NOTIFY) and "dry_run" (a safety toggle on a destructive operation) are 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?

"Resend NOTIFY for one zone" gives a specific verb (resend NOTIFY) and resource scope (one zone), and the term NOTIFY separates it from siblings like bind_refresh_zone or bind_retransfer_zone. It does not explicitly say how it differs from those siblings, keeping it below a 5.

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

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

There is no statement of when to choose this over bind_refresh_zone, bind_retransfer_zone, or bind_reload_zone, nor any prerequisites or exclusions. The trailing caveat hints at a limitation but never tells the agent when the tool is appropriate.

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?

readOnlyHint=true already tells the agent this is a safe read, so the description only needs to add context. It does add one useful trait: the tool surfaces the server's *actual* response code rather than masking it, which hints that NXDOMAIN/SERVFAIL are returned as data rather than errors. It says nothing about timeouts, whether the query recurses, or what the response payload contains.

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 [READ] tag partially duplicates readOnlyHint, but the sentence itself is tight and the key behaviour (exposing the real response code) is not buried.

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 small three-parameter lookup tool with annotations covering safety, the description covers the core action. But with 0% schema coverage and no output schema, the roles of rrtype and especially target (which server is actually queried) are left undocumented, which is a real gap for a diagnostic tool.

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

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

Schema description coverage is 0%, so the description carries the full burden for three parameters — name, rrtype (default A), and target (nullable, default null) — and explains none of them. 'Configured DNS server' weakly implies target overrides the server, but this is guesswork rather than stated 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?

States a specific verb and resource: query the configured DNS server and expose its response code, with a [READ] prefix signalling a non-mutating lookup. It does not, however, distinguish itself from the very similar sibling bind_query_server, which an agent cannot disambiguate from this text alone.

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 guidance. With a near-identical sibling (bind_query_server) and related tools like bind_diagnose_zone and bind_flush_name in the list, the description leaves selection 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?

The '[READ]' prefix merely restates readOnlyHint=true. With annotations carrying the safety profile the bar is lower, but nothing is said about timeout behavior, what happens when the target server is unreachable or non-authoritative, or recursion/EDNS behavior — meaningful context for a network query 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 wording; the [READ] tag is mildly redundant with the annotation but still aids scanning.

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?

Four parameters with zero schema descriptions, no output schema, and an ambiguous nullable 'target' argument — the description does far too little to make this callable correctly given the complexity and sibling density.

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 largely does not: 'record type' maps to rrtype and 'specified DNS server' maps to server, but the meaning of 'name' (query name?) and especially 'target' (nullable, default null) is left 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?

Specific verb+resource: query a DNS server for a supported record type. The word 'specified' hints at the distinction from the sibling bind_query (presumably local/default server), but it never names that sibling or states the boundary 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?

Usage is only implied by 'a specified DNS server' — an agent can infer this is for querying an arbitrary/external server rather than the local one, but there is no explicit when-to-use, when-not, or named alternative among the many bind_* siblings.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral trait beyond that — "transfer completion remains unknown" warns the operation is asynchronous and unverifiable from the response. It says nothing about required permissions, what gets invalidated, or the dry_run escape hatch.

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 the operation class first and the caveat second — nothing padded. The [WRITE] prefix duplicates annotation information, so it earns no credit but costs almost nothing.

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, non-idempotent mutation with zero schema coverage and no output schema, the description is too thin. An agent still doesn't know what target means, how dry_run changes behavior, or what a successful response looks like — all of which the description must supply here.

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 carries the full burden for zone, target, and dry_run. It clarifies nothing: "secondary zone" loosely implies zone, but target (presumably which server to ask) and dry_run (a preview mode that matters for a destructive write) are completely undocumented in both schema and description.

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?

"Ask a secondary zone to refresh" states a specific verb (refresh) and resource (secondary zone), which an agent can distinguish from bind_retransfer_zone's retransfer semantics. The [WRITE] tag reinforces the mutation nature, though the closest sibling (bind_retransfer_zone) is never named or contrasted.

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

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

The phrase "secondary zone" implicitly scopes when this applies (not for primary/authoritative zones), but there is no explicit when-to-use/when-not guidance and no routing advice versus bind_retransfer_zone or bind_reload_zone. The agent must infer the choice between refresh, retransfer, and reload.

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 a non-read-only, non-idempotent, destructive write. The description adds genuinely new context beyond them: the reload is queued rather than executed synchronously, and completion remains unknown. That is exactly the kind of async/fire-and-forget caveat an agent needs. It still omits whether the zone is interrupted and whether config validation failures abort the queue.

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 tight sentence with the operation class front-loaded and no filler. The brevity is appropriate in form even though it leaves gaps that other dimensions penalize.

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, non-idempotent mutation with three parameters at 0% schema coverage and no output schema, this is too thin. An agent gets no information about the target parameter, how to invoke safely, or what a queued result looks like.

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

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

Schema description coverage is 0% and the description communicates almost nothing about the three parameters. 'zone' is inferable from 'zone reload', but 'target' (presumably a view or server selector) and 'dry_run' are left entirely undefined, and the text never hints that a dry-run mode exists.

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: it checks configuration and queues a zone reload. The '[WRITE]' prefix immediately signals the operation class. It does not distinguish itself from siblings like bind_refresh_zone or bind_retransfer_zone, which sound adjacent.

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 and no mention of when not to use it. Several siblings (bind_refresh_zone, bind_retransfer_zone, bind_notify_zone) plausibly overlap, and the description gives an agent nothing to choose between them.

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 a destructive, non-idempotent write. The description adds useful context with 'completion remains unknown', warning that the operation is asynchronous or indeterminate, but it does not explain what is overwritten, required permissions, or how to verify completion.

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 front-loads the write marker and includes the key outcome caveat. There is no filler or repetition beyond the bracketed write tag.

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, non-idempotent, three-parameter mutation with no output schema and zero schema descriptions, the definition omits prerequisites, target semantics, dry_run behavior, and verification guidance. It covers purpose and indeterminacy but is not complete enough for safe invocation.

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

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

Schema description coverage is 0%, and the description does not define zone, target, or dry_run. 'Secondary zone retransfer' weakly implies the zone parameter, but target and dry_run remain semantically opaque, so the description does not compensate for the schema gap.

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

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

The description states a specific verb and resource: 'Request a secondary zone retransfer'. It does not distinguish this operation from sibling tools such as bind_refresh_zone or bind_notify_zone, so sibling differentiation is missing.

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 like bind_refresh_zone, bind_notify_zone, or bind_show_zone. It also gives no conditions for choosing the optional dry_run or target parameters.

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

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

Annotations already declare readOnlyHint=true, and the '[READ]' prefix merely restates that. The description does add real behavioral context: output comes back over rndc's response channel rather than a dump file, which tells the agent no file artifact is produced. It says nothing about permissions, output shape, or failure modes.

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

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

One compact sentence with the operation type front-loaded via '[READ]'. Nothing is wasted, but the terseness comes at the cost of informativeness about the parameter and output.

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

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

For a tool with an undocumented optional 'target' parameter and no output schema, the description should explain what target selects and roughly what is returned. Neither is covered, so an agent cannot confidently invoke it with a target value.

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 'target' parameter has 0% schema description coverage and is not mentioned in the description at all, leaving its meaning (server? view? anchor name?) ambiguous. With one optional parameter the baseline is forgiving, but the description does not compensate for the schema gap.

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

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

The description names a specific verb ('Show') and resource ('trust anchors'), and clarifies the retrieval mechanism ('through rndc's response channel, without a dump file'). It is distinguishable from siblings like bind_dnssec_validation or bind_managed_keys_status, though the phrasing is dense with BIND/rndc jargon.

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 guidance, and no sibling is named as an alternative. An agent must infer that this is for inspecting DNSSEC trust anchors rather than validation state or managed keys, which several nearby tools also cover.

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

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

Annotations already declare readOnlyHint=true, and the '[READ]' prefix merely restates that rather than adding context. The description says nothing about whether the result reflects configuration vs runtime counters, whether it requires a live server connection, or how the answer is presented — and there is no output schema to fall back on.

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

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

One short, front-loaded sentence with no filler; the key concept (stale DNS answers) appears immediately. Minor waste in the '[READ]' tag, which duplicates the readOnlyHint annotation.

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

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

With no output schema, the description carries the burden of explaining what comes back, but it does not say whether the tool reports enablement, active serve-stale responses, or counts. Combined with an undocumented 'target' parameter, the definition is too thin 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?

The single optional parameter 'target' has 0% schema description coverage and is never mentioned in the description. An agent cannot tell whether target means a server, a view, a zone, or a network endpoint, and the description does nothing to compensate for that gap.

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

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

The verb-plus-resource is concrete: 'Show whether stale DNS answers are currently served' names the specific BIND serve-stale feature state being queried. It is distinguishable from most siblings (zone transfers, timeouts, keys), though it does not explicitly contrast with adjacent status tools like bind_status or bind_zone_status.

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 the many other status siblings, no note on prerequisites (is serve-stale required to be enabled/configured first?), and no exclusions. The agent must infer usage 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?

The '[READ]' prefix merely restates the supplied readOnlyHint=true, which earns no credit. The one piece of real context is 'when enabled', implying the zone must be dynamic and active, but the description never says what happens if it is not (error, empty result, or fallback), nor anything about permissions or output shape. With annotations covering only safety, this is a thin disclosure.

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

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

It is a single front-loaded sentence with no filler, and the read tag plus purpose are stated immediately. It is efficient, though the brevity edges into under-specification rather than tightness.

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

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

For a tool with two undocumented parameters, no output schema, and only a readOnly annotation, the description leaves key gaps: what 'target' selects, what the returned configuration looks like, and the failure mode when the zone is not a running dynamic zone.

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% across two parameters, so the description must carry the burden and it largely fails: 'zone' is only indirectly referenced, and the optional 'target' parameter is never mentioned at all, leaving its meaning (server/view/target instance?) 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?

The description states a specific verb ('Show') and resource ('a running dynamic zone's configuration'), which is enough to distinguish it from status/diagnostic siblings such as bind_zone_status or bind_dnssec_zone_status. It stops short of 5 because 'dynamic zone' and 'when enabled' are BIND-specific conditions that are not explained, leaving some ambiguity about scope.

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

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

There is no guidance on when to pick this over the many sibling zone-inspection tools (bind_zone_status, bind_serve_stale_status, bind_compare_soa, etc.), and no explicit exclusions or prerequisites. The only usage cue is the trailing 'when enabled', which hints at a precondition but never states what to do otherwise.

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?

readOnlyHint=true already declares the safe-read profile, so the '[READ]' prefix adds nothing. The one piece of real added context is that results include both in-progress and completed signing state, but nothing is said about whether this hits a live signing queue, costs anything, or how large a result may be for a busy zone.

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 short sentence with the resource front-loaded after the verb, so an agent gets the point immediately. The bracketed '[READ]' token is redundant with the readOnlyHint annotation and could be dropped, but overall there is 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 tool whose inputs are entirely undocumented and with no output schema, the description should explain the 'target' argument and what fields a signing state report contains. It also leaves the agent unable to separate this from bind_dnssec_zone_status or bind_zone_status, so the definition is not sufficient to drive a confident selection.

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% with two parameters, so the description must carry the burden and largely does not. 'A zone's' hints that the zone argument scopes the query, but the 'target' parameter (presumably which BIND instance/server to interrogate) is completely unexplained, leaving half the inputs opaque.

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 concrete verb (List) and a specific resource (a zone's ongoing and completed DNSSEC signing state), which is meaningfully narrower than bind_zone_status. It does not distinguish itself from the closely related siblings bind_dnssec_zone_status and bind_managed_keys_status, which an agent would need in order to choose correctly.

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, and no alternative is named despite at least three sibling tools covering overlapping DNSSEC/zone status territory. The only contextual signal is the bracketed [READ] tag, which implies a query rather than telling the agent when this query is the right one.

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

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

readOnlyHint=true already declares the safety profile, and the description adds genuine behavioral detail beyond that: "active" is defined as only roots containing entries, which tells the agent results are filtered rather than a full dump. It stops short of mentioning pagination, ordering, or empty-result behavior, so it is not a 5.

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 with the purpose front-loaded and the filtering semantics immediately after; every clause carries information and there is no boilerplate.

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 no output schema, the omissions are narrow but real: the undefined `target` parameter and the absence of any hint about result shape or ordering. Annotations cover safety, so the description is nearly complete, but a caller still cannot predict what passing `target` does.

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 is a single optional parameter, `target`, and schema description coverage is 0% - the schema gives only a type and null default with no meaning. The description never mentions what a target is or how supplying one changes the listing, so the agent must guess whether it scopes to an account, region, or root ID.

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?

"List all active security roots" gives a specific verb (list) and resource (security roots), and the read tag plus the use of "active" scopes it against mutation-oriented siblings like create/update/delete security root tools. An agent can tell what this returns 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 verb "List" implies an inventory/read use case, so context is reasonably inferred, but there is no explicit when-to-use statement, no mention of prerequisites or permissions, and no named alternative such as the tool for fetching a single root by ID.

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, so "[READ]" and "without changing them" largely restate structured data rather than adding to it. Nothing is said about whether timeouts are global or per-target, what units or defaults apply, or what the response looks like for a tool with 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?

A single short sentence, front-loaded with the [READ] marker and the resource name; nothing is padded or redundant within the sentence itself. It is arguably too terse rather than too long.

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

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

For a simple read tool this is close to adequate, but the sole parameter is undocumented in both schema and description, and with no output schema the agent has no idea what the return shape or the meaning of "target" is. The definition leaves a real gap before the tool can be invoked confidently.

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 is one optional parameter, "target", with 0% schema description coverage, and the description says nothing about it at all — not whether it is a server, view, zone, or address. With low coverage the description is expected to compensate, and it 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?

Specific verb plus resource: "Show current DNS TCP timeouts" tells the agent exactly what is returned, and "[READ]" plus "without changing them" pins the operation as non-mutating. It is reasonably distinguishable from siblings like bind_fetch_limits or bind_status, though it never explicitly contrasts itself with 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 the usage context (inspecting timeouts, not altering them) but gives no explicit when-to-use, when-not-to-use, or named alternative among the many bind_* status tools. An agent can infer it is a safe inspection call, but routing between it and e.g. bind_fetch_limits is left to guesswork.

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 read-only claim is consistent with readOnlyHint=true, and "live zonestatus" adds the useful nuance that this reports runtime state. It says nothing about what happens if the zone is not loaded, what the status covers, or how the `target` parameter changes 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?

A single front-loaded sentence with zero padding. It is tight, though the brevity is achieved by omitting content rather than by disciplined editing.

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

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

This is a simple read tool with no output schema, but with 0% schema coverage and an undocumented `target` parameter, the description leaves real gaps. A status call typically returns serial, expiry timers, and load state, and none of that is hinted at.

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 carries the full burden. "for one zone" loosely anchors the required `zone` parameter but adds no format or naming guidance, and the optional `target` parameter is not mentioned at all.

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: get BIND's live zone status for one zone. The word "live" usefully signals runtime state rather than config, which helps separate it from siblings like bind_show_zone. It never names an alternative outright, so the differentiation is inferential.

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

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

The "[READ]" tag marks it as non-mutating, but there is no statement of when to prefer this over bind_status, bind_show_zone, bind_dnssec_zone_status, or bind_managed_keys_status. The agent must guess 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 destructive=true, idempotent=false, readOnly=false; the description adds that the inverse executes through its own governed tool and risk tier (audit behavior) and that tokens are single-use. Useful beyond the annotations, though it doesn't say what the inverse might mutate.

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 [WRITE][risk=medium] tag front-loads the mode and risk, and the body is tight. The Args block partially restates the schema titles, but each line adds semantics, so little is wasted.

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

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

No output schema, but the description explains the dispatch model, the dry-run preview path, and the one-time token constraint, which covers the essentials for a mutation tool. It could clarify failure behavior (e.g., applying an already-used token) to be fully complete.

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

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

Schema description coverage is 0%, so the description must carry the load, and it documents all three params: undo_id's source, dry_run's preview semantics, and target's pass-through role. The 'target' explanation ('when it accepts a target') is a bit thin but directionally complete.

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 ('apply') and resource ('a recorded undo') plus the mechanism (dispatching its inverse tool). This clearly distinguishes it from the sibling undo_list, which only enumerates tokens.

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?

Gives concrete guidance: undo_id comes from undo_list or an _undo_id in a write result, use dry_run=True to preview, and a token can only be applied once. It stops short of saying when not to use it or when preview is mandatory, but the context is clear.

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

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

Annotations only declare readOnlyHint, yet the description discloses substantial behavior: an extra row is read so 'truncated' is measured rather than inferred, effectVerified=false means the reversed change is probable not confirmed, and it warns against reporting an unverified restore. This is well beyond what the annotation covers.

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 purpose, then usage, then a non-obvious implementation note, then args. The paragraph on effectVerified is long but every clause carries decision-relevant information; nothing is 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?

No output schema exists, so the description supplies the return shape itself (original tool, inverse tool, human note, truncated, effectVerified) plus the truncation semantics. Nothing an agent needs to call and interpret this tool 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 0%, so the description must carry the burden — and it does: limit is documented with default 50 and a cap of 500 (the cap is absent from the schema), and target is explicitly marked unused and explained as CLI uniformity.

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 ('List recorded, not-yet-applied undo tokens') with ordering scope ('most recent first') and the [READ] marker. It is immediately distinguishable from its sibling undo_apply, which it names.

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 routes the agent onward ('Use the undoId with undo_apply') and gives a conditional check before applying when effectVerified is false. It doesn't state an explicit when-not-to-use case for undo_list itself, but the workflow context is clear.

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