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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is covered. The description adds value beyond them by disclosing 'requires no API key' and 'rate-limited' — operational facts not present in the structured fields. It does not quantify the rate limit, which keeps it short of 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?

Four tight sentences with zero filler: purpose, use case, sibling routing, and operational caveat, with the primary purpose front-loaded. Every sentence earns its place.

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

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

Output schema exists, so return values need not be explained, yet the description still summarises them. With one fully-documented parameter, full annotations, and a clear sibling routing rule, nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100% with a single param whose format ('1.1.1.1' or 'AS13335') is fully documented in the schema. The description restates the accepted input types without adding syntax or edge-case detail, which is the expected baseline when the schema does the heavy lifting.

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 (look up) and resource (ASN/BGP info for an IP or AS number) and enumerates what is returned: operator, prefixes, abuse contact, classification. It also explicitly names the sibling it is not (reverse_dns), so an agent can distinguish it without opening either 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?

Gives explicit use cases (identify who runs a network; check whether an IP is cloud/CDN-hosted) and an explicit alternative with the condition that selects it: 'Use reverse_dns instead for the host-level PTR name of a single IP.' No inference required.

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 readOnlyHint/idempotent/destructive hints already covering safety, the description still adds a great deal: it is rate-limited, it enumerates the exact verdicts (danger, suspicious, unreachable, official, no_signals), it warns that no_signals is not a safety claim, it discloses that 'unchecked' lists what was not examined, and that output includes signals with sources plus a signed observation record. That is unusually rich disclosure and is consistent with the annotations.

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

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

The opening clause is well front-loaded, but the body is a single sprawling paragraph dense with parentheticals and em-dashes (the full payment-provider list, the render caveats) that is hard to scan. Most content earns its place, but the structure does not aid rapid reading.

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 high-complexity tool with nested objects, an enum action, and an output schema, the description covers the important caveats (rate limiting, verdict semantics, unchecked scope). Since an output schema exists it need not restate return shapes, and the main remaining gap is the absent routing against sibling phishing/impersonation tools.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning: it explains why the page structure matters (card fields outside a known payment provider list are reported suspicious, and this is the only way a fake card window inside a real shop surfaces), constrains the structure to host names only, and notes that expectedBrand causes a domain mismatch to be reported. This goes beyond the schema's field-level text.

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 (check) and a precise resource/trigger (the page an agent is about to log in, pay, download from or submit to), then enumerates exactly what is examined: brand impersonation, domain age, feed flags, headless-render behavior, and card-field placement. It is far more specific than a generic 'check page.' It does not, however, differentiate itself from potential siblings like phishing_link_check or impersonation_exposure, so it stops short of a 5.

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

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

The usage trigger is explicit and front-loaded: call it before logging in, paying, downloading, or submitting. It also states input exclusions (paths, queries, field values and page text are not accepted, structure not stored), which is a useful 'when-not' for arguments. It never names an alternative sibling or explains when a different check would be preferable, so no 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?

Annotations already cover readOnly, idempotent, openWorld, and non-destructive, so the safety profile is handled elsewhere. The description adds real value beyond them: no API key or authentication required, rate limiting applies, and results are severity-rated diagnostics rather than raw records. It stops short of describing pagination or error/failure behavior, keeping it at a 4.

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 routing information (what it does, when to use it, which siblings to prefer) is front-loaded in the first three sentences, with operational notes trailing. Slightly long, and the closing sentence describing the returned text report partially duplicates the output schema, but every sentence is informative.

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 explaining return values in detail is unnecessary, yet the description still summarizes the report shape. Combined with the auth/rate-limit disclosure and explicit sibling routing, an agent has everything needed to invoke this correctly.

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

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

Only one parameter and schema coverage is 100%, so the schema already fully documents the domain format including the no-scheme/no-trailing-slash guidance. The description adds no parameter-level detail beyond that, so the baseline 3 is correct.

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 (Query) and resource (DNS records), enumerates supported record types (A, AAAA, MX, TXT, NS, SOA, CAA), and adds the validation scope (DNSSEC presence, SPF/DMARC syntax). It explicitly distinguishes itself from dns_propagation and email_auth, so an agent can select it correctly without opening any 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?

Gives explicit when-to-use ('a single authoritative answer about one domain') and two named alternatives with the exact conditions that select them: dns_propagation for cross-resolver comparison after a change, email_auth for full deliverability assessment. Nothing is left 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the bar is lower. The description still adds real operational context: named resolver set, no API key required, and rate-limited. It stops short of quantifying the rate limit or describing concurrency/retry 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?

Four tight sentences, purpose front-loaded before the routing guidance and behavioral notes. The final sentence on return values ('per-resolver values and a consistency verdict') partially duplicates the existing output schema, which slightly dilutes the conciseness.

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

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

An output schema exists so return values need not be spelled out, and annotations carry the safety profile. The description supplies the routing and resolver-coverage context an agent needs; only minor gaps remain around rate-limit specifics and failure behavior when a resolver is unreachable.

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

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

Schema description coverage is 100%, so both parameters (domain, type with enum and default) are already fully documented in the schema. The description adds only the framing that one record type is compared across resolvers, not new syntax or format guidance, so baseline 3 applies.

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

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

The description gives a specific verb (query/compare) and resource (one DNS record across 8+ named public resolvers) and explicitly frames the outcome (stale vs updated per resolver). It is immediately distinguishable from dns_lookup, which it names as the single-answer 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?

It states the exact trigger ('use this after changing a record to confirm worldwide propagation') and routes to the sibling with an explicit condition ('use dns_lookup instead for a single authoritative answer with SPF/DMARC validation'). Both when-to-use and when-not-to-use are covered.

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 cover the read-only/idempotent/non-destructive safety profile, but the description adds real context: it requires no API key, is rate-limited, and operates from two sources (daily watch timeline, or the diff of the last two stored lookups). The rate-limit disclosure is vague (no numbers), which keeps it from 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?

Front-loaded with the core purpose, then usage, sources, and return/behavioral notes. It is fairly dense with several sentences, but each adds decision-relevant information rather than filler. Slightly long relative to the single-parameter surface.

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 spelled out, yet the description still summarizes the return shape (monitored tools, newest-first timeline, lookup-to-lookup changes, management link). Combined with the two-source explanation and point-in-time contrast, an agent has everything needed to call it correctly.

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

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

Only one parameter and the schema already documents it at 100% coverage (including the scheme/path stripping behavior), so the schema carries the semantics. The description adds no further parameter detail, so the baseline of 3 applies.

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

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

The description states a specific verb+resource: reporting what changed for a domain over time, enumerating the monitored dimensions (SSL grade, headers, DNS, OWASP posture, impersonation exposure). It clearly separates itself from the point-in-time tools (security_scan, owasp_check, ssl_check). It does not, however, distinguish itself from the close sibling 'domain_history' or 'watch_domain', leaving some ambiguity among similarly named 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?

Explicit when-to-use ('answer what changed since yesterday/last week', 'first check when a domain comes up again') and explicit alternatives ('the point-in-time tools give the current state instead'). It even states the condition that makes it meaningful (requires persistent snapshots, cannot be reconstructed from a live lookup).

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 readOnly/idempotent/non-destructive/openWorld, yet the description adds material context beyond them: no API key required, rate-limited, the precise observation sources and the daily re-resolution caveat, plus the shape of the return (per-kind value timelines and a coverage note). This is unusually rich disclosure for a read-only 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?

Front-loaded with the core purpose, then usage routing, then coverage limits — well ordered and free of filler. It is dense with many clauses in one long sentence, but each clause carries distinct, useful information, so sizing is justified though not maximally tight.

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 detailed, and the description still sketches them (per-kind timelines + coverage note). Combined with explicit coverage limitations, safety/rate-limit notes, and alternative-tool routing, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100% and the single 'target' parameter already documents domain/IPv4 format and stripping behavior. The description only echoes that it accepts a domain or IPv4 address, adding no syntax or format detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource: it shows how a domain's or IPv4's infrastructure has changed over time, and enumerates the exact observation kinds (nameservers, A/AAAA, MX, CNAME, cert issuer, registrar, RDAP, ASN/PTR). It also distinguishes itself from dns_lookup and rdap_lookup, so an agent can route between them without opening schemas.

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

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

Explicitly scopes usage to past-tense questions with concrete examples ('when did the nameservers change?', 'which IPs has it used?') and names the alternatives (dns_lookup, rdap_lookup) for current state. It also states the coverage boundary — only DechoNet's own observations, not full passive DNS — which is exactly the when-not guidance an agent needs.

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 readOnly, idempotent, openWorld and non-destructive, but the description adds context annotations do not carry: no API key required, rate-limited, and the depth of probing (15 DKIM selectors, blacklist across all MX hosts). It also discloses the return shape (text report with score, per-mechanism KPIs, issues, actions), which is real behavioral value beyond the structured fields.

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 verb, resource, and scope before any routing or behavioral notes; the mechanism list is dense but each item is load-bearing for what the check covers. Three short sentences, no filler or restatement of the title.

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

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

For a one-parameter read-only assessment tool with an output schema, the description covers purpose, coverage, alternatives, auth/rate-limit traits, and return shape. An agent has everything needed to select and invoke it correctly without inspecting the 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?

There is a single parameter with 100% schema description coverage, and the schema already explains that the value is the part after '@' and that an IP is accepted for PTR checks. The description adds no syntax, format, or constraint information beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb (Assess) and resource (a domain's email authentication and deliverability posture), then enumerates the exact mechanisms probed (MX, SPF, DMARC, DKIM with 15 selectors, BIMI, MTA-STS, TLS-RPT, DANE, blacklist) and the 0-100 score output. It explicitly distinguishes itself from dns_lookup and email_header_analysis, so an agent can route without opening sibling schemas.

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

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

Gives a positive use case (full sending/receiving readiness review) and two explicit alternatives with the conditions that select them: dns_lookup for raw TXT/MX records, email_header_analysis for a specific already-sent message. When-to-use, when-not-to-use, and routing are all covered.

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 readOnly, idempotent, non-destructive, and openWorld, so the safety bar is lower. The description still adds non-obvious operational context the annotations cannot convey: no API key required and the tool is rate-limited, plus a summary of what the report contains. It stops short of quantifying the rate limit or noting failure modes on malformed input.

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?

Capability is front-loaded in the first sentence, followed by usage, alternative, and operational notes in a tight sequence with no filler. The trailing INPUT/OUTPUT sentences are somewhat redundant given a full output schema exists, which is the only real slack.

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

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

For a single-parameter read-only diagnostic tool with both annotations and an output schema, the description covers purpose, selection criteria against the closest sibling, input expectations, and behavioral constraints. Nothing an agent needs in order to call it correctly is missing.

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

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

Schema description coverage is 100% and the single parameter's schema text is already detailed (verbatim block, folded lines, no body). The description's 'INPUT is the full raw header block' merely restates that, adding no syntax or format detail beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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 precise verb chain (parse, reconstruct, extract, measure, flag) against a specific resource (raw email headers) and enumerates the exact analytical outputs. It explicitly distinguishes itself from the sibling email_auth, so an agent can route between them without opening either 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?

It gives an explicit when-to-use ('diagnose a specific message that was already delivered — spoofing, delays, or where mail was lost') and an explicit alternative with its own condition ('Use email_auth instead to assess a domain's sending configuration before sending'). Both the trigger and the exclusion are spelled out.

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 cover readOnly/openWorld/idempotent/non-destructive, and the description adds substantial non-obvious context: public view only, the per-host list and sensitive-file check gated behind DNS TXT ownership verification, passive behavior beyond one first-page request per host, no logins or path guessing, no API key, and a heavy rate limit (~1 minute). That is exactly the behavioral layer structured fields cannot express.

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 front-loaded with the core action and scope, and dense with useful traits rather than filler. The single long sentence-plus-clause structure is heavy to parse, and a couple of framing phrases ('the forgotten assets AI-driven attack tools look for first') are color rather than load-bearing, but nothing is redundant.

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 elaboration, yet the description still orients the agent ('counts per category, a verdict, and what to do'). Combined with the verification gating, rate limit, and no-API-key notes, an agent has everything required to call this correctly.

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

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

There is a single parameter with 100% schema description coverage, and the schema already explains the domain format including the stripping of scheme/path/leading www. The description adds no syntax, format, or constraint information beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb (map), a specific resource (externally exposed assets beyond the home page), and an enumerated scope (subdomains from CT logs, categorized into dev/ops tools, admin screens, VPN logins, staging, etc.). It is clearly distinguishable from siblings like subdomain_discovery or impersonation_exposure by its categorization-and-verdict framing.

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 states explicit trigger conditions: 'when a user wants to know their attack surface or after a breach in their sector.' That is clear when-to-use guidance, but it never names a sibling (e.g., subdomain_discovery, impersonation_exposure) as the alternative for narrower cases, so it stops short of full when/when-not routing.

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

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

Annotations cover the safety profile, yet the description adds substantial context: the verdict logic (failing essential -> not_ready, cautions -> caution, all clear -> ready), the passive-probe caveat that it nonetheless resolves and fetches, no API key required, and rate-limiting. It honestly reconciles 'read-only' with active network behavior, which is exactly the kind of nuance an agent needs.

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

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

Four sentences, each double-loaded: verb+scope first, then when-to-use, then disambiguation, then verdict semantics and constraints. The most decision-relevant content (what it checks and when to call it) is front-loaded 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?

With an output schema present, the description need not explain returns, yet it still sketches them (verdict, per-check statuses, report link). Combined with usage guidance, verdict rules, and the read-only/rate-limit caveats, nothing needed to call this correctly is missing.

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

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

Only one parameter and schema coverage is 100%, so the schema already documents 'domain' including scheme/path stripping. The description adds no syntax or format detail beyond that, so the baseline 3 applies.

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

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

States a specific verb ('Check whether a domain is ready') plus resource and enumerates all five essentials it evaluates (DNS resolution, propagation, SSL/TLS, HTTPS reachability, expiry). It also distinguishes itself from siblings by naming security_scan and 'the individual tools' explicitly, so an agent can route without opening another 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?

Provides explicit timing ('right before flipping DNS to a new server, or to confirm a migration has landed') and frames the decision it answers ('can I switch over yet?'). It names alternative tools (security_scan, individual tools) and the condition that selects them (depth vs. posture grade), leaving nothing 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?

Beyond the annotations (readOnly, idempotent, non-destructive), the description adds that the probe is HTTP GET-style with no payload, requires no API key, is rate-limited, follows redirects, and discloses what the report contains (grade, findings, redirect trace, issues, actions). These are behavioral facts the annotations cannot convey.

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

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

Front-loaded with the core action before the graded-header detail, exclusions, and behavioral notes; each sentence carries substantive information. It is dense but not padded, though the parenthetical header lists are lengthy enough to border on over-specification.

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

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

For a read-only one-parameter audit tool with an output schema, the description covers purpose, sibling routing, safety profile, prerequisites, and output shape. An agent has everything needed to select and invoke it correctly.

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

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

Schema description coverage is 100% for the single 'url' parameter, and the description adds little beyond it — the redirect-following behavior it mentions is already documented in the schema's url description. Baseline 3 is appropriate when the schema carries 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?

States a specific verb+resource: follows a URL's HTTP redirect chain and audits response security headers, enumerating exactly which headers are graded (six core) versus reported (COOP/CORP/COEP) and the A+–F grading scale. It explicitly names the closest siblings (ssl_check, security_scan) and the layer it owns, so an agent can distinguish it without opening any 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?

Gives an explicit selection rule: 'Use this for HTTP-layer/header posture', then routes certificate/TLS-handshake concerns to ssl_check and full-domain reporting to security_scan. Both the when-to-use and when-not-to-use conditions are stated, leaving nothing 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?

Annotations already declare readOnly/openWorld/idempotent/non-destructive, but the description adds substantial context beyond that: the operation is fully passive, sends nothing to the target or lookalikes, uses public DNS delegation and CT-log queries, is rate-limited, and returns a shareable report link. It also flags an important interpretive caveat (a registered lookalike is exposure to verify, not proof of impersonation), which is genuine behavioral guidance.

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 paragraph is long but well front-loaded with purpose, then method, grade, caveat, passivity, alternatives, and constraints. Nearly every sentence earns its place, though the passive/no-data-sent point is restated and could be tightened slightly.

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

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

Given an output schema exists, the description need not explain returns, yet it usefully summarizes the report contents (grade, counts, per-category findings, report link). Together with the method, constraints, and caveat, an agent has everything needed to call and interpret this 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 100% for the single 'domain' parameter, and the schema already documents that scheme/path are stripped and gives an example. The description adds no parameter-level syntax beyond what the schema provides, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Assess how exposed a domain is to brand impersonation and phishing') and enumerates the exact checks performed (typosquat/lookalike domains, CT-log subdomains, wildcard cert). It explicitly distinguishes itself from lookalike_domains and subdomain_discovery, so an agent can separate it from siblings without opening another 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?

Names the alternative tools and the condition that selects them ('Use lookalike_domains or subdomain_discovery for the raw per-tool detail'), routing the agent to this tool for the aggregated grade. It also states prerequisites (read-only, no API key, rate-limited) and the passive operating constraint.

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 readOnly/idempotent/non-destructive, and the description goes well beyond them: API-key requirement with exact header and env-var forms, the 20-row-per-call limit, rate limiting, and the key operational caveat that shared infrastructure degrades to a count. Coverage limitation (only DechoNet's own observations) is also 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 and purpose, then layered with the degradation rule, auth requirements and limits. Dense but every clause carries operational information; the auth parenthetical is slightly compressed but not wasteful.

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

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

Output schema exists so return values need no explanation, and the description supplies everything else an agent needs: prerequisites, sequencing relative to sibling tools, auth, quota and coverage limits. Nothing material to correct invocation is missing.

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

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

Schema coverage is 100% with an enum for kind and an example for value, so the baseline is 3. The description adds real meaning by naming which infrastructure categories the enum members correspond to (nameserver, IP address, MX host, certificate issuer, registrar), tying abstract enum strings to concepts, though it does not explain individual enum members one by 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 (find) and resource (other domains sharing an infrastructure value) plus the scope of the pivot values (nameserver, IP, MX, certificate issuer, registrar). Gives a concrete motivating example (other phishing domains on the same rare nameserver), so an agent can distinguish it from dns_lookup or reverse_dns without opening either 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?

Explicit about when to use it — 'after domain_history or dns_lookup gives you a distinctive value' — and when it is useless, since shared infrastructure (CDNs, public CAs, large registrars) returns only a count. Both the trigger condition and the negative case are named.

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 cover read-only, idempotent, open-world, and non-destructive behavior, while the description adds operational context beyond them: no input, no API key, rate limiting, and the important caveat that this reflects the MCP server's network egress IP. This extra context helps an agent interpret the result correctly.

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-loads the purpose and field list, then adds the no-input clarification, usage guidance, alternatives, and operational traits. The sentences are short and earn their place, with only minor redundancy in restating read-only.

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 no-parameter read tool with rich annotations and an output schema, the description is complete: it explains result type, the server-egress nuance, alternatives, and operational constraints. Return-value details are appropriately 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 has zero parameters, and the description confirms this by saying it takes no input. With no parameter semantics to clarify, the baseline for a zero-parameter tool 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?

States a specific verb and resource: reports the caller's own public IP as seen by the server, enumerating fields such as IPv4/IPv6, ISP, ASN, geolocation, and proxy/VPN heuristics. It explicitly distinguishes itself from asn_lookup and reverse_dns, which inspect a specific known IP instead.

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

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

Provides clear when-to-use: discover the server's outbound IP or test connectivity. It also gives the alternative when a specific known IP must be inspected, naming asn_lookup and reverse_dns, and warns that the result is the server's egress IP rather than the end user's IP.

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 readOnly/openWorld/idempotent/non-destructive, and the description adds what they cannot: no API key required, rate-limited, detection method (live NS delegation via DoH), and an important interpretation caveat that a registered variant is not proof of abuse. That result-semantics disclosure materially changes how an agent should act on output.

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 dense paragraph, front-loaded with the verb and the technique list, with no filler sentences. It is longer than strictly necessary and the technique enumeration stacks heavily, but every sentence carries operational information (caveat, follow-up, constraints, return shape).

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

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

Despite an output schema already existing, the description summarizes return values (generated/checked counts plus registered variants tagged with the producing technique), and it covers constraints, interpretation limits, and next steps. Nothing an agent needs to select or invoke this tool correctly is missing.

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

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

With a single parameter at 100% schema coverage, the schema already documents format and exclusions (no scheme/path). The description adds marginal value by stating that both the label and the TLD are used to generate and check variants, which clarifies scope beyond the parameter's own text.

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 pair — generating typosquat/lookalike variants and checking which are registered via DoH — and enumerates the exact technique families (homoglyph, TLD swap, omission, transposition, repetition, hyphenation), so an agent can distinguish it from siblings like dns_lookup or whois_lookup without opening schemas.

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

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

Explicitly frames the use case (brand-impersonation/phishing exposure for a domain the user is responsible for) and routes the follow-up step to whois_lookup on each hit, which is concrete guidance. It stops short of naming when NOT to use it versus siblings such as impersonation_exposure, so it is clear context without full alternative coverage.

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 read-only/idempotent/open-world, but the description adds substantial behavior beyond them: it only sends initialize and tools/list, never calls a tool, strips query strings before sending or storing, restricts to public addresses, requires no API key, and is rate-limited. It also discloses what is deliberately not checked and 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?

Front-loaded with the core action, and given the breadth of what is checked the length is largely justified. It is one dense run-on paragraph with heavy parentheticals (RFC 9728, tool poisoning, CORS and Origin) that would read better as a short list, costing it a point.

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

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

An output schema exists, so return values need not be detailed, yet the description still summarizes the return (status, KPIs, issues, actions, unchecked items, shareable report link). Combined with scope limits, transport behavior, and access constraints, an agent has everything needed to call it correctly.

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

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

With a single parameter at 100% schema coverage the baseline is 3, but the description adds a real constraint not in the schema: only public addresses are accepted, and it reinforces the query-string stripping with the rationale that nothing is sent or stored with the query.

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 ('Check a remote MCP server from outside') and enumerates exactly what is inspected: auth/OAuth metadata, world-acting tools, tool-poisoning text, CORS/Origin, HTTPS, annotations. This is clearly distinguishable from siblings like ssl_check or security_scan, which cover narrower surface areas.

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

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

The intended moment is explicit: 'before connecting it to an agent.' It also implicitly defines when-not by stating what is out of scope (behind-login code, actual tool behavior) and flagging those as 'not checked.' It does not, however, name a sibling tool as an alternative for related checks.

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 readOnly, idempotent, non-destructive and open-world, so the safety profile is covered; the description still adds substantive context beyond them — the check is PASSIVE (normal HTTPS request, TLS cert, CT-log lookup, no port scan/path probing), the sensitive-file check never runs through this tool, and it is rate-limited with no API key. Strong disclosure, though the rate-limit specifics are qualitative rather than quantified.

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 scope and safety before details, and most sentences carry distinct information. Slight redundancy: 'The result is an external-posture check, not a full OWASP Top 10 assessment' restates the scope already established by the category enumeration.

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, yet the description still usefully characterizes the return (grade, per-category findings, out-of-scope list, shareable link). Combined with the scope, passivity, and alternative guidance, an agent has everything needed to select and call it correctly.

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

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

Only one parameter with 100% schema coverage, and the schema already documents the no-scheme format and the pasted-URL acceptance. The description adds no parameter syntax beyond that, but with a single fully documented parameter the baseline is high.

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 ('Assess a domain's OWASP posture') and immediately bounds it ('from EXTERNAL OBSERVATION only'). It names the exact categories checked (A02, A03, A04) and explicitly names the sibling tools (http_security, ssl_check) it is not, so an agent can route without opening schemas.

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

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

Explicit when-to-use (external posture, domains you do not own), when-not (A01/A05/A06/A07/A08/A09/A10 are out of scope), and named alternatives for depth on a single layer. Nothing is left 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?

Adds substantial context beyond the annotations: how links are resolved through shorteners, the exact signal set consulted (RDAP age, brand impersonation, ClickFix, APK, punycode, feeds), the verdict taxonomy including the important caveat that no_signals is not a safety assertion, the isolated-Chromium fallback under a shared daily cap, and the explicit statement that it does not click, enter values, or submit forms. It also discloses privacy (message not stored), no API key, and rate limiting.

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-loads purpose and the trigger condition, then the signal list and caveats. It is dense and long for a one-parameter tool, and the signal enumeration could be trimmed, but nearly every clause carries operational information an agent would otherwise lack.

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 the description still summarizes the verdict shape and shareable report link. Combined with the privacy, rate-limit, and no-side-effect disclosures, nothing needed to call this tool correctly is missing.

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

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

Schema description coverage is 100% and the single parameter is already documented, including the up-to-5-link limit and the no-storage note. The description reinforces the paste-whole-message-vs-single-URL semantics but adds little the schema does not already state, so baseline 3 applies.

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

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

Names a specific action and resource: extract, resolve, and judge links in a suspicious message/URL. It is clearly distinguishable from sibling lookups (dns_lookup, ssl_check, whois_lookup, lookalike_domains) because it deliberately composes those signals into a phishing verdict rather than exposing a single raw record.

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 an explicit trigger condition: 'Use this when a user asks whether a link or message is a scam.' It does not name a competing sibling or state when not to use it (e.g. when only a bare domain's DNS/TLS data is wanted instead), so routing guidance is clear but not exhaustive.

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, destructiveHint=false and idempotentHint, but the description goes well beyond them: it discloses that this makes an ACTIVE TCP connection, that the probe does not authenticate or send exploits, that it changes nothing on the target yet is visible in target logs, that no API key is needed, and that it is rate-limited. This is exactly the context an agent needs before invoking a scanning 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?

Dense but front-loaded, with a labelled BEHAVIOR section and no filler sentences; every clause carries operational value. It is a single long paragraph where light structuring would aid scanning, keeping it just short of 5.

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

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

Given one required parameter, full schema coverage, rich annotations, and an output schema, the description covers everything an agent needs: scope, side effects, authorization, rate limits, and routing to alternatives. Return-value detail is rightfully deferred 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?

Schema coverage is 100% and the host parameter description already covers hostname/IP form and the host:port hint, so the baseline is 3. The description adds the fixed-port-set scope but no additional parameter syntax or format detail beyond the schema.

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

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

States a specific verb (probe) and resource (host TCP ports) with the exact scope: a fixed common-port set covering HTTP/HTTPS/SSH/FTP/SMTP/DNS and databases. It also names the sibling tools it is not (ssl_check, http_security), so an agent can distinguish it without opening any 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?

Explicit when-to-use ('confirm which services are exposed') and when-not ('use ssl_check or http_security instead to assess a specific service's configuration'), plus a hard authorization precondition. Nothing is left 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?

Annotations already cover readOnly/idempotent/non-destructive/open-world, but the description adds substantial context beyond them: no API key required, rate-limited, the CDN-to-origin leg is invisible, certificate chain is tracked but not scored, and the 'unknown vs no' distinction. This is exactly the extra context an agent needs to interpret 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?

Front-loaded with the core purpose, then scope, verdicts, and return shape in a logical order. It is dense and long, but nearly every clause carries decision-relevant information (verdict semantics, limitations). Minor trimming possible in the verdict enumeration.

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

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

For a read-only, single-parameter tool with an output schema, the description covers everything needed: what is checked, what is not observable, verdict meanings, scoring, and limitations. Return-value redundancy with the output schema is minor and does not detract.

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

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

Schema description coverage is 100% and the single 'domain' parameter is fully documented in the schema (including scheme/path stripping). The description adds no syntax or format detail beyond that, so the baseline 3 is appropriate for a schema-does-the-work case.

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 (Check) and a tightly scoped resource: whether a website's public TLS endpoint completes a TLS 1.3 handshake offering only the hybrid X25519MLKEM768 key exchange. The post-quantum framing and port-443-only scope clearly distinguish it from the generic ssl_check sibling, so an agent can route correctly without opening the schema.

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

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

The description defines scope boundaries (public endpoint on port 443; internal systems, VPNs and code not observable) and explains each verdict, which implies when the tool is appropriate. However, it never explicitly names ssl_check or any sibling as the alternative, nor states a when-not-to-use condition. Usage is inferable but not spelled out.

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?

Goes well beyond annotations: states the 90-day retention, exactly what data is kept (host+kind, anonymous reporter hash; endpoint path for malicious_mcp; observed values and country for network_anomaly), explicitly that no query/page text/free text is stored, that a report changes no verdict by itself, and that DechoNet re-opens the page. Also discloses rate limiting.

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-loads the verb and kind list well, but the first sentence is a very long run-on enumerating eight kinds with parenthetical definitions, and the retention/privacy sentences pack many clauses. Dense and information-rich but harder to scan than necessary.

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 an output schema, it covers privacy/retention, rate limits, what a report does and does not do, and the kind-specific data requirements. An agent has everything needed to call it correctly without reading the schema.

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

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

Schema coverage is 100% so baseline is 3, but the description adds meaning the schema lacks: which kinds require observed data (network_anomaly), that url for malicious_mcp is the MCP endpoint, and that observed holds certificate serial/issuer or addresses. Useful layered detail beyond the enum descriptions.

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

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

States a specific verb (report) and resource (page) plus enumerates all eight report kinds with definitions, e.g. fake_payment means 'card fields where a payment provider should be'. This distinguishes it from every sibling, which are lookups/checks rather than reporting endpoints.

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

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

Implies when to use by enumerating the situations (phishing, fake payment window, hidden instructions, wrong verdict, missed danger, steering MCP server, network anomaly) and explains the false_positive/missed cases for reporting a bad DechoNet verdict. No explicit exclusions or named alternative tools, so not 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?

Annotations already cover read-only, idempotent, non-destructive and open-world traits, but the description adds genuinely new context: no API key required, rate-limited operation, and the non-obvious FCrDNS verification pass/fail behavior. It does not quantify the rate limit or describe failure modes on an invalid/missing PTR, so it falls short of the richest behavioral 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?

Front-loaded with the core action, then use cases, then the alternative, then behavioral caveats, then return summary — no filler sentences. The return-value sentence is mildly redundant with the output schema but is short and reinforces expectations.

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

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

For a one-parameter lookup with rich annotations and an output schema, the description covers purpose, routing to the alternative, auth/rate-limit context, and the verification semantics. An agent has everything needed to select and call it correctly without consulting other tools.

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

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

Schema description coverage is 100% and the single 'ip' parameter is fully documented in the schema (IPv4/IPv6, must be an IP not a hostname). The description restates 'IPv4 or IPv6' but adds no format, syntax, or edge-case meaning beyond the schema, so it sits at the baseline 3.

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 (resolve the PTR record) and expands it with the FCrDNS verification step and provider inference, so the full behavior is clear. It explicitly names the sibling asn_lookup as the wrong tool for network/BGP ownership, letting an agent distinguish it without opening either 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?

Gives concrete use cases ('validate mail-server rDNS', 'identify a single IP's host') and an explicit alternative with its selecting condition ('Use asn_lookup instead for network/BGP ownership'). No usage decision is left 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?

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the bar is lower; the description still adds substantial unrepeatable context: passive-only (no port scans), the scoring weighting (quarter/half penalties), unreadable data flagged not charged, failed lookups reported as not checked, ~1 minute runtime, no API key, and rate limiting. It stops short of documenting partial-failure retry semantics but covers the operation profile well.

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 summary and organized into scoring, behavior and return sections; nearly every sentence carries decision-relevant content. It is dense and on the long side, but the detail on scoring and passivity justifies most of its length.

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

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

For a complex, multi-area audit tool the description fully covers scoring, exclusions, failure handling and runtime, and even summarizes returns despite an output schema existing. An agent has everything needed to call it correctly and set expectations.

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

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

Single parameter at 100% schema coverage, so the schema already documents 'domain' and stripping of scheme/path. The description adds behavioral nuance (www-host measurement) but no parameter-specific syntax or format beyond what the schema provides, matching the baseline-3 rule.

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?

Opens with a specific verb+resource+scope ('One-shot comprehensive audit of a domain') and immediately enumerates the five scored areas. It also names the sibling tools (ssl_check, email_auth, exposure_map) and distinguishes itself from port_scan, so an agent can place it without opening a 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?

Explicitly defines when to use it (one-shot comprehensive audit) versus when to go deep on one area ('Call the individual tools... for depth'), and routes the active check to port_scan. Both inclusion and exclusion conditions 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?

Annotations only give the safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false). The description adds real behavioral depth beyond that: fresh non-cached reads from its own servers plus a Seoul observation point, daily re-check cadence, pass/fail/unknown semantics where unknown is never a pass, anonymous-vs-API-key behavior including 30-day retention and daily mail, and the explicit 'stores the set' mutation disclosure that reinforces destructiveHint=false.

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, and each subsequent sentence carries distinct information (execution model, result semantics, auth tiers, use case). It is a single dense paragraph of long clauses rather than a bulleted, scannable structure, which costs a point but not efficiency.

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 nested check definitions and an output schema, the description covers what's needed: what is stored, how results are produced, auth/retention differences, and the daily re-check behavior. Return details (set id, status page, receipts) can be read from the output schema, so the description is complete without repeating 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?

Schema description coverage is 100%, so the schema already documents domain, label, and the full expect item structure including its per-check kinds. The description restates check examples in prose (HSTS/DMARC/grade/cert days/DNS) rather than adding syntax the schema lacks. It adds a small amount — 'any domain is accepted' and the meaning of unknown — but largely echoes the structured fields, so the baseline 3 applies.

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

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

States a specific verb+resource ('Record what a domain should show from outside and check it now') and then enumerates the concrete check kinds (HSTS header, DMARC enforcing, issue key absent, TLS grade, cert days, DNS records). An agent can distinguish this from verify_expectations and watch_domain from the description alone: this tool creates the set, the others re-check or watch.

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 an explicit triggering scenario — 'after changing DNS, TLS, headers or mail settings, to state the intended result and be told if it is ever reverted.' That is clear context. It stops short of naming exclusions or the sibling it replaces (verify_expectations vs watch_domain), so it misses the 5 bar.

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 cover the safety profile (readOnlyHint, destructiveHint=false, idempotentHint, openWorldHint), and the description adds real behavioral context beyond them: one full TLS handshake plus ClientHello messages with only the first answer read, no application data, no vulnerability probes, no API key required, and rate-limited. It also discloses grading weights and how weak findings cap the grade.

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 purpose and routing guidance are front-loaded in the first and middle sentences, and every clause carries information an agent could act on (grading weights, handshake behavior, sibling alternatives). It is dense and long—the cipher-suite and TLS-3.0/SEED/ARIA detail is more than most selection decisions need—but not padding.

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 two-parameter read-only diagnostic with annotations and an output schema present, the description covers everything selection-relevant: scope, safety, limitations, alternatives, and grading logic. Return values are summarized without needing to duplicate 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?

Schema description coverage is 100%, so both parameters (host, port) are already fully documented with defaults and format guidance. The description adds no syntax, format, or edge-case meaning beyond the schema, so the baseline of 3 applies.

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

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

The description names a specific verb and resource (inspect a host's served TLS/SSL certificate and connection) and enumerates exactly what is examined: expiry, issuer, SAN list, chain integrity, revocation, TLS version, HSTS, plus a letter grade. It also names the sibling tools it is not (http_security, security_scan), so an agent can disambiguate without opening schemas.

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

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

Explicit when-to-use ("diagnose certificate or HTTPS-handshake problems for one host") paired with explicit alternatives for adjacent tasks ("Use http_security instead to audit response security headers, or security_scan for an all-in-one domain report"). Routing is unambiguous.

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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds materially beyond that: full passivity with the justification (no packets sent, CT logs are public), no API key required, rate-limiting, and which name patterns it flags. These are operational traits an agent cannot infer from structured fields.

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 and purpose, and most sentences earn their place (passivity rationale, alternative routing). The final sentence enumerating return values is somewhat redundant given an output schema exists, which keeps this just below a 5.

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

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

For a one-parameter, read-only reconnaissance tool, the description covers purpose, safety, prerequisites, sibling routing, and expected output shape. An agent has everything needed to select and invoke it correctly.

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

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

Schema description coverage is 100% and the single 'domain' parameter is well documented (registrable domain, no scheme/path). The description adds no syntax or format detail beyond the schema, so the baseline 3 applies when the schema already does the work.

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 (enumerate), resource (subdomains), and source mechanism (Certificate Transparency logs), which is far more than a restatement of the name. It explicitly contrasts itself against siblings by naming dns_lookup and lookalike_domains, so an agent can route without opening either 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?

"Use this as the first recon step to map a domain's attack surface" gives explicit positioning, and it names two alternatives with the condition that selects each (dns_lookup for resolution checks, lookalike_domains for typosquats). Nothing about when-to-use is left 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?

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld=false), so the bar is lower. The description adds genuine value with RFC 3021 handling for /31 and /32, the absence of API-key/rate-limit concerns, and the text return format. The 'no network call' point partially restates openWorldHint=false, but the edge-case semantics are additive.

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 purpose but spends three separate sentences restating the same idea — 'entirely locally', 'does not query DNS or contact any host', and 'no API key / NOT rate-limited (computed in-process)'. That redundancy dilutes an otherwise tight definition.

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 and annotations covering the safety profile, the description need not explain return values; it still notes the text format. Parameter semantics are covered by the 100%-covered schema, so nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100% and the single 'cidr' parameter is fully documented in the schema (IPv4 with prefix 0-32, host bits permitted). The description repeats 'CIDR notation' without adding syntax or format detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Compute IPv4 subnet details from CIDR notation') and enumerates exactly which outputs are produced (network/broadcast addresses, host range, host count, masks). The 'entirely locally — no network call' framing cleanly separates it from the network-querying siblings like dns_lookup and ip_info.

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

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

Provides a usage context ('Use this for IPv4 address planning') and implicitly rules out lookup tools by stating it contacts no host. However, no alternative sibling is named and no explicit when-not condition is given, so routing is only implied rather than resolved.

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?

Adds substantial context beyond the annotations: rate limiting (a few checks per minute), the 'unknown is never a pass' outcome rule, that each tool is read once and a signed observation receipt is produced, and the 30-day retention of the anonymous set. This is well beyond what readOnlyHint/idempotentHint convey.

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

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

A single dense paragraph that front-loads the two modes and then layers outcomes, receipts, and rate limits. Every clause carries information, though the density makes it slightly taxing to parse.

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

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

For a tool with an output schema and full schema coverage, the description supplies modes, outcome semantics, retention, and rate limits. Return-format details are correctly delegated to the output schema, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds real value by clarifying the mutually exclusive usage modes (id from set_expectations vs. domain+expect once, storing nothing) that the flat schema does not express.

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 ('check expectations from outside now') and spells out the two operating modes — stored set by id vs. one-off domain+checks. It explicitly relates itself to the sibling set_expectations, so an agent can distinguish them without opening a 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?

Gives a concrete context ('typical use: right after a change, to see whether it is visible from outside yet') and notes external DNS/CDN propagation lag. It references set_expectations as the stateful counterpart, but never states an explicit 'use set_expectations instead when…' exclusion, so the when-not is only implied.

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

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

Goes well beyond the annotations: discloses idempotent reuse of an existing watch, that it is a write despite being non-destructive, that no account/email/PII is required, that the history page is a public but unguessable shareable URL, and that it is rate-limited to a few watches per minute. Annotations (readOnlyHint=false, idempotentHint=true) are consistent and the description enriches rather than repeats them.

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

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

A single dense paragraph, front-loaded with the action, then usage trigger, then follow-on tool, then behavioral caveats. Every sentence carries distinct information — no restatement of the name or title, 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 values need not be explained, and the description still covers the operational facts an agent needs before calling: idempotency, rate limit, no-auth requirement, and shareability of the resulting page. Nothing required to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so parameter documentation is already complete (baseline 3). The description adds meaning by spelling out what the recorded artifacts actually are (SSL grade/issuer/expiry, DNS records, HTTP security headers, domain registration) and by noting that scheme/path are stripped from the domain, which helps the agent reason about what the 'tools' selections buy.

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 ('Start (or reuse) a daily DechoNet watch on a domain') and enumerates exactly what it records (SSL, DNS, HTTP headers, registration, optional OWASP/impersonation). It distinguishes itself from the one-off siblings ('beyond a one-off check') and from domain_changes/domain_history, so an agent can route correctly without opening schemas.

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

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

Explicit when-to-use trigger ('Use this once when the user cares about a domain beyond a one-off check — their own domain, a client, a vendor, a target under investigation') plus the follow-on relationship ('After this, domain_changes answers "what changed since last time?"'). This is routing-grade guidance, naming both the alternative and the condition that selects this tool.

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

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

Annotations already declare read-only/idempotent/non-destructive/open-world, and the description adds context those annotations cannot express: no API key required, rate-limited, RDAP with WHOIS fallback behavior, and risk-state surfacing (clientHold, pendingDelete). This is meaningful operational disclosure beyond the structured fields.

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?

Four short sentences with the core action front-loaded, then routing guidance, then caveats. The closing return-value summary mildly overlaps the opening sentence, but it is brief and does not bloat the definition.

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, yet the description restates them; that is the only redundancy. For a one-parameter read tool, routing, auth, and rate-limit context are all present, leaving nothing an agent needs 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?

With a single parameter at 100% schema description coverage, the schema already documents the domain argument and even its subdomain-normalization behavior. The description adds no format, syntax, or edge-case detail beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Retrieve domain registration data via RDAP') plus the exact fields returned (registrar, dates, nameservers, EPP status flags). It explicitly distinguishes itself from dns_lookup, reverse_dns, and asn_lookup, so an agent can route without opening any 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?

It states the use case ('ownership, lifecycle, and expiry questions about a registered domain') and names three alternatives with the condition each covers (live DNS records, IP-level ownership). Both when-to-use and when-not-to-use are present.

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