Whisper

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful behavioral context beyond that: it explicitly states no API key is required and mentions that multiple indicators can be assessed, though the exact format for multiple indicators is not specified.

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

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

The description is compact and front-loaded with the core purpose, followed by a useful authentication note and a concrete example. Every sentence contributes value without redundancy.

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

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

For a single-parameter tool with an output schema and safety annotations, the description is nearly complete. The only notable gap is the ambiguous 'one or more indicators' phrasing, which is not reconciled with the singular input 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 the schema already documents the input parameter well. The description adds the 'one or more indicators' nuance and an example call, but it does not clarify how multiple indicators should be encoded in the single string parameter.

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

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

The description states a specific action ('Assess') and a specific resource ('risk/policy posture of one or more indicators'), which clearly differentiates it from generic lookup siblings. It does not explicitly name a sibling alternative, but the purpose is concrete enough to avoid confusion.

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

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

The intended use is implied by the purpose: use this when you need risk/policy assessment of an indicator. However, there is no explicit guidance about when not to use it or which sibling tool might be a better fit for other indicator lookups.

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 carry readOnlyHint and openWorldHint, and the description adds a useful auth-relevant detail ('Answers without an API key') plus a hint that the result is a catalog of attributes. It does not go into rate limits, failure behavior, or output format, but for this simple read-only lookup the extra context is adequate.

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

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

Three short sentences deliver purpose, a behavioral note, and an illustrative example with no repetition or filler. The main purpose is front-loaded and 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?

With a single well-documented parameter, an output schema available, and annotations covering safety, the description covers the essential context for calling the tool. The example call and API-key note round out the picture; only sibling differentiation 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%, and the parameter description already lists all accepted indicator types (domain, IP, ASN, file hash). The description only reinforces this with an example, adding no new semantic information beyond the schema.

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

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

The description names a specific verb ('Resolve') and resource ('an asset and its catalog of attributes'), making the core function clear. It does not explicitly differentiate from sibling tools like whisper_identify or whisper_lookupTlsFingerprint, but the asset-attributes framing gives enough distinctiveness.

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

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

The description implies when to use the tool: when you need to resolve an asset and its attribute catalog from an indicator. However, it provides no exclusions or explicit comparisons to sibling tools, and the 'no API key' note is the only additional usage signal.

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

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

Annotations already communicate readOnly, openWorld, and non-destructive behavior. The description adds the useful fact that it answers without an API key, but otherwise does not disclose additional behaviors such as response shape or limitations. No contradiction with annotations.

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

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

Two short sentences carry a clear definition, a key operational fact, and a concrete example with no filler. The most important phrase is front-loaded.

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

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

For a one-parameter lookup tool with a full input schema, output schema, and read-only annotations, the description provides the essential operational context. It could be slightly more explicit about how an indicator maps to a 'verdict', but the example and schema cover that gap well enough.

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

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

The input schema fully describes the single parameter, including the accepted value types (domain, IP, ASN, file hash), so schema coverage is 100%. The description's example adds a concrete illustration but does not go beyond what the schema already states.

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 ('Explain') and a specific resource ('a verdict - the evidence and reasoning behind it'), which clearly sets it apart from sibling actions like assess or identify. The example call reinforces the intended input.

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

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

The description implies the tool is appropriate when you need the evidence/reasoning behind a verdict and notes it works without an API key, but it does not explicitly name alternatives or state when not to use it. Context is implied rather than direct.

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 mark the tool as readOnly and non-destructive; the description adds the meaningful behavioral detail that no API key is required and that the data is historical rather than current. This supplements the annotations without contradicting 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?

The description is compact and front-loaded with the core purpose, then adds the access note and a concrete example call. Every sentence earns its place 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?

Given the simple single-parameter schema, a provided output schema, and annotations covering the read-only safety profile, the description is complete enough for an agent to understand what the tool does, what input it needs, and that no API key is required.

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

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

The input schema fully documents the single 'input' parameter with a clear description of accepted indicator types (domain, IP, ASN, file hash). The tool description adds little beyond an example call, so the schema carries the semantic weight.

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

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

The description clearly states the tool provides 'Historical records for an indicator' and specifies the scope with '(incl. whois/bgp history)'. This distinguishes it from real-time lookup tools like whisper_rdap or whisper_lookupTlsFingerprint, though it does not explicitly name a sibling 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?

The description implies usage for historical lookups and explicitly notes that it 'Answers without an API key', which is a useful access condition. However, it does not say when to prefer this over siblings or provide exclusion criteria, leaving the decision to the agent's 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 readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds one useful behavioral detail: 'Answers without an API key', which is a notable access requirement. It does not mention response format or error behavior, but the output schema may cover that.

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

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

The description is exceptionally concise: two sentences and a code example. It front-loads the purpose and immediately provides a callable example. Every part earns its place with no wasted words.

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

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

For a simple one-parameter tool with an output schema, the description is largely sufficient. It tells the agent what input to provide, that no API key is needed, and gives an example. It doesn't mention error conditions or alternative routing, but these are not critical for basic invocation.

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

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

Schema description coverage is 100% – the parameter is fully described ('domain, IP, ASN, or file hash') and includes an example. The tool description's example call adds a concrete usage pattern, but since the schema already explains the parameter well, the description adds little beyond that.

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 ('Identify') and resource ('an indicator against the graph'), with clear scope (domain, IP, hash, etc.). It is distinct from siblings like whisper_lookupTlsFingerprint or whisper_rdap in that it is a general-purpose lookup, but it doesn't explicitly name alternatives to aid differentiation.

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

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

The description provides an example call but offers no guidance on when to use this tool versus its many siblings (e.g., whisper_verify, whisper_lookupTlsFingerprint). It does not state prerequisites, exclusions, or when an alternative is more appropriate.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint, so the safety profile is covered. The description adds value by noting that no API key is required, a behavioral trait not present in the annotations. The phrase 'in the graph' gives context about the data source. No contradiction with annotations.

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

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

The description is concise: two sentences plus an example, all informative. The main purpose is front-loaded, and the example call is immediately useful. There is no filler or redundant information.

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

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

The tool has only one parameter, an output schema, and annotations, so complexity is low. However, the input semantics are ambiguous: the description implies the input should be a TLS fingerprint, while the schema lists domains, IPs, ASNs, and file hashes. The example helps but does not fully clarify whether all these indicator types are accepted or if only JA3/JA4 strings should be passed. This ambiguity prevents a higher score.

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's example call demonstrates a concrete input format, but the schema already contains this example. The description does not clarify the discrepancy between the tool name (TLS fingerprint) and the schema's broader indicator types (domain, IP, ASN, file hash), so it adds minimal semantic value.

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

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

The description states a specific verb and resource: 'Look up a TLS (JA3/JA4) fingerprint' and provides an example call. This clearly distinguishes it from sibling tools like lookupTorRelay by the fingerprint type. The 'in the graph' phrase and example make the tool's purpose unambiguous.

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

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

The only guidance is 'Answers without an API key,' which is a benefit rather than a when-to-use condition. It does not mention alternatives, prerequisites, or when not to use this tool. No comparison to siblings like lookupTorRelay is provided, leaving the agent to infer appropriate usage from the name alone.

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

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

The description adds a concrete behavioral detail beyond the annotations: 'Answers without an API key,' which clarifies authentication expectations. The readOnlyHint, openWorldHint, and destructiveHint annotations already cover safety, and the description does not contradict 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?

The description is two tight sentences: the first states the purpose, the second provides authentication context and a concrete example. Every sentence earns its place with no filler or repetition.

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

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

For a simple one-parameter lookup tool with an output schema and safety annotations, the description is largely complete. The only notable gap is the mismatch between the description's 'address' and the schema's broader accepted indicator types, which could lead an agent to underuse the tool.

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

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

Schema coverage is 100% and the input parameter is fully described, so the baseline is 3. The description's example call illustrates the expected JSON format but does not add meaningful semantic detail beyond what the schema already provides.

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

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

The description clearly states the action and resource: 'Look up Tor relay metadata for an address.' This distinguishes it from generic lookup tools. However, it says 'address' while the schema supports domains, IPs, ASNs, and file hashes, creating a slight scope mismatch that prevents a 5.

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

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

The description implies the tool is for Tor relay lookups and notes that no API key is needed, which gives some usage context. But it provides no explicit guidance about when to choose this tool over its siblings, such as whisper_lookupTlsFingerprint or whisper_identify, nor any exclusions.

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

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

Annotations already cover read-only and non-destructive behavior, and the description adds the meaningful extra that no API key is required—an authentication trait not visible in annotations or schema. It does not go into data sources or rate limits, but the annotation coverage lowers the bar.

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

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

The description is compact and front-loaded: purpose first, then the no-API-key note, then a concrete example call. Each sentence earns its place, and the example illustrates the skill/input structure not fully captured in the schema.

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-string-parameter tool with an output schema and safety annotations, the description plus schema provide enough to invoke it correctly. The main gap is the absence of explicit sibling differentiation, but the tool is simple enough that this is a minor completeness issue.

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

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

The input schema has 100% coverage and already documents that input can be a domain, IP, ASN, or file hash. The description only restates 'indicator' and provides an example call, adding minimal semantic value beyond the schema.

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

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

The description states a specific action ('Trace') and object ('origins/provenance of an indicator'), so an agent can tell what the tool does. It does not contrast itself with sibling tools like whisper_history or whisper_variants, which keeps it from a 5.

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

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

The description implies when to use the tool: when provenance or origin of an indicator is needed. It also gives a practical condition ('Answers without an API key'), but it provides no explicit when-not-to-use guidance or alternatives among the many sibling tools.

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

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

Annotations already cover the read-only, open-world, non-destructive profile, so the bar for extra disclosure is lower. The description adds the genuinely useful fact that it answers without an API key, but it does not mention input validation, error behavior, or rate limits, leaving transparency average.

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

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

The description is short and front-loaded with the family identity and an example. It contains redundancy: the sub-verbs are listed in the first sentence and again in the third sentence, and there is a stray double period in 'affiliation..'.

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 two fully described required parameters, an output schema, and annotations covering safety, an agent has what it needs to construct a valid call. The description provides the missing accepted sub-verb values and a concrete example; a fuller definition of each sub-verb's return semantics is not necessary given 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%, warranting a baseline of 3, but the description adds real value by listing the accepted sub-verb values and giving a full example call that maps "sub" and "input" to concrete values. Without enums in the schema, this list is important for correct invocation.

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

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

The description names the tool as a public-suffix-list family and enumerates its sub-verbs (tldPlusOne, isPublicSuffix, affiliation), so an agent can tell it apart from unrelated siblings like whisper_rdap or whisper_origins. It is clear and specific, though it does not explain what each sub-verb computes.

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 explicit call construction guidance ('name the sub-verb as "sub" alongside the input') and a concrete example, making the mechanics of use clear. However, it never states when to prefer this family over alternatives or when not to use it; the usage context is implied rather than explicit.

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

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

Annotations already mark the tool as read-only, open-world, and non-destructive; the description adds that it is public, requires no API key, and returns the same RFC 9083 document served at /ip/{address}, along with the specific fields. This is useful context beyond the annotations and does not contradict 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?

Three short sentences plus an example, front-loaded with the core meaning and returning field list. The middle sentence about the RDAP service being publicly readable is mildly redundant but reinforces the access model.

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 tool with full schema coverage and an output schema, the description supplies the key operational facts: output format, an example call, and the lack of an API key requirement. The main gap is the ambiguity between address and the schema's accepted indicator types, though the schema resolves it.

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

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

The schema already fully documents the single parameter with 100% coverage, listing domain, IP, ASN, or file hash as valid inputs. The description adds a concrete example call and repeats address, but its address and /ip/ wording does not fully align with the schema's broader indicator list, so it neither strengthens nor significantly clarifies the schema.

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

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

The description identifies a concrete resource: the public RFC 9083 registration record for an address, and lists the returned fields including handle, agent label, country, and entities. It is distinct from sibling tools like whisper_lookupTorRelay or whisper_lookupTlsFingerprint, though the use of address and the /ip/ endpoint slightly undercuts the schema's broader domain/ASN/hash scope.

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

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

The description states that the tool answers without an API key and that the same document is served by the RDAP service, implying it is a simple public read for registry information. It does not name alternatives or exclusion conditions, so the agent must infer when to choose this over other whisper tools.

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

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

Annotations already indicate this is not read-only and not destructive, which lowers the bar. The description adds meaningful behavioral detail: an email is sent, a code is delivered, a key is issued, and the key unlocks certain skills. Nothing contradicts the annotations.

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

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

The description is compact and front-loaded with the core purpose, then follows with the operative protocol and an example. Every sentence contributes necessary information; the only minor extra is the phrase 'on this card,' which is harmless platform context.

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

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

For a two-step signup flow, the description fully explains prerequisites, the payloads for each step, and the expected result of receiving an API key. Since an output schema exists, the absence of return-value details is appropriate. An agent has all the information needed to invoke this tool correctly.

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

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

The schema only provides a generic 'input' object, so the description carries the full semantic load. It gives the exact payload shapes for both phases—{'email':'...'} and {'signup_id':'...','code':'123456'}—plus a concrete example call. This goes well beyond what the input schema alone communicates.

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, observable outcome: start or complete Whisper signup from an email address and receive an API key. It also conveys the two-phase nature of the operation, which clearly separates it from the read/lookup-focused sibling 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?

The description provides a concrete invocation path: send an email first, receive a six-digit code, then send the signup_id and code to complete. It also clarifies that no human step or prior account is needed. It does not explicitly name alternatives, but no sibling appears to offer signup functionality, so the omission is minor.

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 mark the tool read-only, open-world, and non-destructive; the description adds useful behavioral context by disclosing that no API key is required and that the tool is a family dispatcher that needs a 'sub' verb. No statement contradicts the annotations.

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

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

The description is compact and front-loaded, with a clear example sentence. The phrasing 'A family verb: name the sub-verb as "sub" alongside the input' is slightly awkward and the trailing dots after sub-verbs are sloppy, but overall every sentence contributes.

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 family dispatcher with an output schema and helpful annotations, the description covers auth requirements, example invocation, and the sub-verb mechanism. It does not exhaustively document every possible sub-verb or the semantics of the returned indicators, but the provided information is sufficient for a basic call.

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 value by enumerating actual sub-verb values and giving a full example call with input=5. This partially compensates for the lack of enum constraints on 'sub'.

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

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

The description clearly identifies this as a threat-intelligence indicator family and lists concrete sub-verbs (candidateCdnApex, candidateMultiTenantApex, candidateSharedHostingIp), making it distinguishable from the sibling whisper_* tools. It is slightly less crisp than a single-action tool because the actual operation is selected via 'sub', but the family and example call make the scope clear.

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

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

The intended use is implied by the threat-intelligence indicator family label and sub-verbs, but there is no explicit when-to-use guidance or comparison to sibling tools. The note 'Answers without an API key' gives one access condition, but not when to choose this tool over alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context that no API key is required, which is beyond the annotations. It doesn't go into return format or pagination, but the output schema exists to cover that.

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

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

The description is exceptionally concise—two sentences—and front-loads the core purpose. Every word earns its place, and the example call is compact and illustrative. No filler or redundant phrasing.

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

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

For a simple read-only tool with one parameter and an output schema, the description is complete. It states the purpose, notes the no-API-key requirement, and provides a concrete example. Safety and parameter details are handled by annotations and schema, leaving no critical gaps.

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

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

Schema coverage is 100% and the schema description for 'input' already states 'A row limit' with an example. The description's example call repeats this without adding new semantic detail. The parameter is fully documented by the schema, so a baseline 3 is appropriate.

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

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

The description clearly states the verb 'Top' and the resource 'ASNs' ranked by 'announced-prefix count'. It distinguishes this from sibling tools, which cover different functions like assess, lookup, etc. The purpose is immediately unambiguous.

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

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

The description provides clear context by noting 'Answers without an API key', which informs the agent about prerequisites. It also gives an explicit example call. However, it does not mention when not to use this tool or alternatives, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds the auth-relevant detail that it 'Answers without an API key,' which is useful context beyond the annotations. However, it does not disclose what kinds of variants are produced or any rate-limit/scope constraints, leaving some behavioral gaps.

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

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

Two concise sentences plus an example call, with the core action front-loaded. There is no filler, and the example demonstrates the exact call shape, making the definition efficient and easy to parse.

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

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

For a single-parameter, read-only tool with a provided output schema, the description covers the purpose, auth requirement, and an example call. It omits explicit alternative-selection guidance, but that falls under usage guidelines and does not undermine completeness for a straightforward 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%, so the input parameter is already fully documented as a domain, IP, ASN, or file hash. The description adds the notion of enumerating variants but no additional syntax or format details beyond the schema.

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

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

The description uses a specific verb 'Enumerate' with a clear resource 'variants/permutations of an indicator,' making the tool's purpose distinct from siblings like whisper_identify or whisper_lookupTorRelay. The title 'variants' is expanded into an actionable statement.

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

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

The description gives context ('Answers without an API key') that implies a no-credential usage scenario, but it does not explicitly state when to prefer this tool over alternatives or mention any exclusions. The example call provides a template but no routing guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description adds substantial behavioral detail beyond that: it explains the full trust-chain verification steps, states that a negative result returns is_whisper_agent with evidence rather than an error, and notes that no API key is required. This gives the agent a strong model of the tool's actual behavior.

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

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

The description is front-loaded with the core question, then adds method, return semantics, auth requirements, and an example—each sentence earns its place. The example call is compact and immediately actionable. It is longer than two sentences, but nothing feels redundant or ornamental.

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 verification tool with an output schema and read-only annotations, the description is complete: it defines the input scope, the verification method, the output flag, the treatment of negative results, and the lack of an API key requirement. An agent has enough context to call this tool correctly without needing to open 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 schema already describes the input string as a broad 'domain, IP address, ASN or file hash', so baseline is 3. The description adds value by narrowing the practical input to IPv6 addresses or hostnames and by providing a concrete example call with a full IPv6 address. There is slight tension with the schema's broader indicator list, but the description still materially clarifies the parameter.

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

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

The description leads with a specific question—'Is this IPv6 address or hostname a real Whisper agent, and whose?'—which names the verb, resource, and scope. It then details a concrete method (reverse DNS, forward AAAA, DANE-EE pin) that clearly distinguishes this from the sibling tools like whisper_rdap or whisper_lookupTlsFingerprint.

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

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

The description gives clear context for when to use the tool: to determine whether an IPv6 address or hostname is a real Whisper agent and to attribute it. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5, but the intended scenario is unmistakable.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds an important behavioral/auth fact—'Answers without an API key'—and demonstrates the minimal call shape. No contradiction 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?

Three short sentences: main purpose first, key auth characteristic second, invocation example third. Every sentence earns its place and no redundant wording is present.

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

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

With a single documented parameter, strong annotations, and an output schema present, the description covers purpose, auth, and call shape. It does not detail graph depth or relationship types, but those details are less critical given the output schema and simple interface.

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%: the input schema already documents that input is a domain, IP, ASN, or file hash. The description's example call and example.com add no new semantic constraints 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?

The description names a specific action ('walk') and resource ('the graph from an indicator across its relationships'), so an agent can tell it performs relationship traversal. It does not explicitly distinguish it from graph-adjacent siblings, which keeps it from a 5.

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

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

The graph-walk context and the 'Answers without an API key' note give clear when-to-use context, and the JSON example shows exactly how to invoke it. It names no alternative/exclusion, so it falls short of explicit guideline quality.

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

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

The description adds the note that it answers without an API key, which is useful auth context. But it doesn't disclose whether the watch operation has side effects (despite readOnlyHint=false), rate limits, or what the 'watch' implies (e.g., polling vs. subscription). The annotations already hint at open world and non-read-only, but the description doesn't elaborate.

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

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

The description is concise and front-loaded with the purpose. The example is a useful addition. However, it sacrifices necessary detail for brevity, so it's not as well-structured as it could be. It earns a 4 for efficiency, but not a 5 due to missing critical information.

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

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

Given the tool has an output schema and is part of a large suite, the description is insufficient. It doesn't explain the full range of operations (only 'list' is shown), doesn't describe the output format, and doesn't clarify the behavioral contract. An agent would struggle to use this tool correctly beyond the one example.

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

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

The schema has only a single 'input' object parameter, and the description provides an example with an 'action' field. However, it doesn't enumerate possible actions, required fields, or format. The schema description itself is vague ('Arguments for this operation'), so the example is the only real guidance, but it's insufficient for an agent to construct correct calls beyond that one example.

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

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

The description states a clear purpose: watching an indicator for change/activity over time. However, it doesn't specify what constitutes an 'indicator' or how this differs from sibling tools like whisper_history or whisper_origins. The example shows an 'action' parameter, but the full scope of actions is unclear.

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

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

No explicit guidance on when to use this tool versus alternatives. It doesn't mention scenarios or exclusions. The only hint is 'Answers without an API key,' which is more about authentication than usage context.

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