Whisper

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds value by stating it answers without an API key, a behavioral detail not present in annotations. It also shows an example call. However, it does not describe output format or limitations, which is acceptable given annotations cover the safety profile.

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

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

The description is a single clear sentence followed by a concrete example call. It is front-loaded with the core purpose, uses no filler words, and each element earns its place. The example is concise and illustrative, making it easy for an agent to parse.

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

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

For a simple one-parameter tool with no output schema and annotations covering read-only and open-world nature, the description is nearly complete. It explains what the tool does, provides an example, and notes the API key requirement. Minor gaps like output format are not critical given the tool's simplicity and the absence of an 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%, and the input field already has a detailed description listing accepted types (domain, IP, ASN, file hash) and an example. The description's example (example.com) mirrors the schema's example, adding little beyond what the schema provides. Baseline 3 is appropriate when the schema carries the parameter semantics.

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

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

The description clearly states the action ('Assess') and the resource ('risk/policy posture of one or more indicators'), making the purpose specific and unambiguous. The inclusion of an example call ('example.com') further clarifies what the tool accepts. This distinguishes it from sibling tools focused on other operations like explain, identify, or walk.

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 one piece of usage context: 'Answers without an API key,' which hints at when the tool is appropriate (no auth required). However, it does not explicitly state when to prefer this tool over alternatives or when not to use it. The purpose implies usage, but there is no routing to 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 declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds the behavioral fact that no API key is required, which is useful beyond the annotations. There is no contradiction, and the additional info is relevant for invocation.

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

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

Two sentences plus a compact example. The purpose is front-loaded, the example is immediately useful, and there is no redundant or filler content. The definition is tight and efficient.

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

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

For a single-parameter read-only tool with annotations covering safety and no output schema, the description provides enough context for a correct invocation: it explains the input type via schema, gives an example, and notes the no-key requirement. Minor gaps like output format or error behavior exist, but they are not critical for this simple 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%, and the input description already enumerates accepted types (domain, IP, ASN, file hash). The description's example adds a concrete instance but does not introduce new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description states a clear verb ('Resolve') and resource ('an asset and its catalog of attributes'), which is specific and informative. It provides an example call that reinforces the purpose. However, it does not explicitly contrast with sibling tools like whisper_identify or whisper_origins, so it lacks differentiation from alternatives.

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 notes 'Answers without an API key', which is a practical usage condition, and the example implies a direct lookup workflow. But it does not specify when to prefer this tool over siblings or when not to use it, leaving usage guidance implicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by stating 'Answers without an API key,' which is not present in the annotations or schema.

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

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

The description is two sentences plus an example, with the core purpose front-loaded and no filler. Every sentence earns its place, and the example call is compact and illustrative.

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 no output schema, the description is complete: it states what the tool does, what input it expects, and that no API key is required. Nothing essential for invoking it correctly is missing.

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

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

Schema description coverage is 100%, so the schema fully documents the single parameter. The description adds an example call but does not provide additional semantic meaning beyond the schema's own description of acceptable indicator types.

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 ('Explain a verdict') and the object ('the evidence and reasoning behind it'), making the tool's purpose clear. It does not explicitly differentiate from sibling tools, but the concept of a verdict is distinct enough among the sibling names.

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

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

The description implies when to use the tool: when a verdict needs explaining, with an example call showing the expected input. It does not provide explicit exclusions or name alternative tools, but the context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context that the tool answers without an API key and that it covers whois/bgp history, but it does not disclose anything about output format, limits, or behavior for unknown indicators.

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 sentences, front-loads the core purpose, and includes a compact example call. Every piece contributes useful information, and there is no redundant restating of the tool name or 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 simple, read-only, single-parameter lookup tool with strong annotations, the description provides enough to call it correctly: purpose, indicator scope, authentication requirement, and an example. A brief note on the return format would be beneficial since there is no output schema, but this is a minor gap.

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

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

The input schema already provides 100% coverage of the single parameter, describing valid indicator types. The description adds a concrete example call but no new semantic detail about the parameter itself, so it meets the baseline without going beyond it.

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

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

The description clearly states the resource ('historical records for an indicator') and gives concrete data types (whois/bgp history), so an agent can tell this apart from a generic lookup. It does not explicitly name or contrast a sibling tool, which keeps it from a 5, but the intent is unambiguous.

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

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

The description gives clear context: use this when historical indicator records are needed, and it notes that no API key is required. However, it does not explicitly say when NOT to use it or which sibling tools to prefer for other kinds of lookups, so the guidance 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 declare this read-only and non-destructive. The description adds meaningful behavioral context beyond the annotations: no API key is required and the lookup is performed 'against the graph.' It does not discuss rate limits or return shape, but given the annotation coverage, this is a solid disclosure of the tool's operating context.

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

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

The description is two short sentences plus an example, with the core action front-loaded. Every element earns its place: purpose, indicator types, auth behavior, and a concrete call format. There is no filler or redundancy.

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

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

Given the low complexity of this one-parameter, read-only lookup tool and the presence of rich annotations, the description plus schema is nearly sufficient: it gives input semantics, auth requirements, and an example. The only notable gap is no description of the output, which is a minor issue since there is no output schema to fill that gap.

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

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

Schema description coverage is 100%, and the schema already explains that input can be a domain, IP, ASN, or file hash. The description largely restates those types and adds an example call. The example is mildly useful for showing invocation format, but it does not substantively extend meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Identify an indicator (domain, IP, hash, …) against the graph.' It lists accepted indicator types, making the tool's scope concrete. However, it does not explicitly contrast with similar sibling lookups like whisper_lookuptorrelay or whisper_threatintel, so it is clear but not fully differentiated.

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 useful usage context by noting 'Answers without an API key' and giving an example call, which implies how and when the tool can be invoked. It does not, however, state when to use this tool versus the sibling whisper_* tools or give any exclusion guidance, leaving the decision to inference.

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the 'Answers without an API key' fact, which is behavioral context beyond the annotations. However, it doesn't describe what the response looks like (no output schema), nor does it mention rate limits or any other side effects. Since the annotations cover the core behavioral traits and the description adds the API key requirement, a 3 is appropriate.

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 sentences, with no fluff. It front-loads the core purpose ('Look up a TLS fingerprint') immediately, then provides the key usage constraint ('without an API key') and a concrete example. Every sentence carries meaningful information, and the example call at the end is a helpful, non-redundant addition. This is a model of 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?

For a single-parameter, read-only lookup tool, the description is nearly complete. The schema covers the parameter fully, and annotations cover the behavioral contract. The description adds the API key fact and a concrete example, which covers the essential usage context. The only minor gap is that the return format is not described, but since there is no output schema, the agent must infer it. Given the simplicity, this is acceptable, so a 4 is appropriate.

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

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

The schema description coverage is 100%, so the parameter 'input' is fully described in the schema as 'The indicator to look up: a domain, an IP address, an ASN or a file hash.' The description repeats this by showing an example with 'ja3:771,4865-4866-4867,' which confirms the format for TLS fingerprints. This adds some value by illustrating the exact input format for this tool, which the schema does not show. Since the schema covers the parameter semantics and the description reinforces with an example, 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 begins with a specific verb and resource, 'Look up a TLS (JA3/JA4) fingerprint,' which is clear. The sibling list includes other lookup tools like whisper_lookuptorrelay, so the inclusion of JA3/JA4 distinguishes it from those. The description also names a specific format for the input, which further differentiates it and adds clarity.

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,' which provides a clear condition for when to use it versus tools that do require a key (though no sibling explicitly mentions API keys, this is useful context). It doesn't explicitly name alternatives or say 'use this instead of X,' but the context and the 'without API key' hint provide clear guidance on when to choose this tool over others that might need authentication. The example call also shows the expected input format, which helps the agent understand how to construct the call.

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, so the safety profile is covered. The description adds the useful context that the lookup 'answers without an API key', which is a practical behavioral detail. It does not describe return format, rate limits, or failure behavior, but with annotations covering the key traits, this is acceptable.

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

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

Two concise sentences front-load the purpose and include a concrete example call. Every element earns its place—there is no filler, and the example is genuinely useful for an agent to see invocation format.

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 lookup tool with rich annotations, the description is adequate but not complete. There is no output schema, yet the description does not explain what Tor relay metadata the response contains or how to interpret results. Error or edge-case behavior is also absent, so an agent would have to infer the return structure.

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 in the schema as accepting a domain, IP, ASN, or file hash. The description adds an example call format but no extra semantic detail about the parameter. The baseline of 3 applies because the schema handles 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 names a specific verb and resource: 'Look up Tor relay metadata for an address.' This clearly states the tool's purpose and the domain-specific resource makes it distinguishable from siblings like whisper_lookuptlsfingerprint. It does not explicitly call out sibling differences, but the resource focus is strong enough for an agent to identify the tool's role.

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

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

The description provides no guidance on when to choose this tool over alternatives. It states the example call and the no-API-key benefit, but never explains when to use Tor relay lookup versus other lookup tools such as whisper_lookuptlsfingerprint or whisper_origins. There are no exclusions or alternative routing hints.

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 non-destructive behavior, so the description's burden is lower. It adds the useful detail that no API key is needed, but it does not disclose output format, limitations, or response behavior. 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 three short sentences, front-loaded with the core purpose, followed by a relevant auth note and an illustrative example. Every sentence earns its place, and there is no filler.

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

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

For a single-parameter, read-only lookup tool with full schema coverage and safety annotations, the description is mostly complete. The only notable gap is the absence of any mention of the response shape or format, which matters more because no output schema is provided.

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

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

Schema description coverage is 100%, so the input schema already fully documents the parameter as a domain, IP, ASN, or file hash. The description's mention of 'indicator' and the example call only restate schema information without adding format or normalization details.

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, 'Trace', and a clear resource, 'origins/provenance of an indicator', with a concrete example call. It is unambiguous about what the tool does, though it does not explicitly distinguish itself from sibling tools like whisper_history or whisper_identify.

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

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

The description provides no guidance on when to use this tool versus its many siblings, and it does not mention alternatives or exclusion criteria. The note that it answers without an API key is an operational convenience, not a usage guideline.

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 the 'no API key' fact and explains the family verb structure, providing additional transparency beyond annotations. It does not describe return format, but the read-only nature is well-covered.

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

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

The description is front-loaded with the core family name and sub-verbs, followed by a usage note and example. It is slightly verbose due to the example and trailing '..' typo, but overall it is efficient and well-structured.

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

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

While the tool is simple and annotations cover safety, the description does not specify the output format or behavior for each sub-verb. An agent may not know what the return value looks like, especially since there is no output schema. This is a minor gap for a tool that could return varied results per sub-verb.

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% for both parameters, and the description enriches them further by listing the allowed sub-verb values and giving an example input. This adds meaning beyond the schema, making it clear what each parameter accepts.

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's domain (public-suffix-list) and enumerates its sub-verbs (tldPlusOne, isPublicSuffix, affiliation), making its purpose unambiguous. It also includes a concrete example that anchors the tool's behavior, distinguishing it from other whisper_* tools that serve different functions.

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

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

The description explains that no API key is required and provides a call example, which gives clear context on how and when to invoke it. It does not explicitly list exclusions or alternative tools, but given the tool's niche purpose, the guidance is adequate for an agent to decide when to use it.

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

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

Annotations already signal non-read-only and open-world behavior. The description adds valuable behavioral detail: a six-digit code is emailed, two sequential payloads are required, and no prior account is needed. It does not contradict the annotations.

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

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

Three sentences deliver purpose, step-by-step protocol, and an example call with no filler. The most important information 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?

For a tool with no output schema, the description explains the expected result ('receive an API key') and the full invocation flow. It could be more explicit about the response field names, but the examples and protocol are sufficient for correct invocation.

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

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

The schema only describes a generic 'input' object, but the description provides concrete payload examples for both phases: {'email':'...'} and {'signup_id':'...','code':'123456'}. This adds meaning far beyond the schema's minimal coverage.

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

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

The description names a specific verb-resource pair: 'Start or complete Whisper signup from an email address alone, and receive an API key.' It also clarifies the two-phase nature of the operation and its outcome, making it unmistakable among the whisper_* siblings.

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

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

It gives clear context for when to use the tool: when an API key is needed to unlock provisioning and governance skills, with no human step or prior account. It does not explicitly name alternatives or exclusions, but the signup purpose is distinct enough that this is a minor gap.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds the useful behavior that answers require no API key, but it does not discuss rate limits, error handling, or output characteristics. Given the annotation coverage, the added context earns a baseline score.

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

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

The description is relatively short but suffers from a typo (double period after candidateSharedHostingIp), awkward phrasing ('family verb'), and a slightly disjointed structure. The purpose is front-loaded, but the overall presentation is mediocre.

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 sub-verb list is incomplete (trailing '..') and there are no enums in the schema, leaving the agent uncertain about valid values. With no output schema, the description also does not hint at the return shape, which is a significant gap for a dispatcher 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 both parameters are already documented. The description clarifies that 'sub' holds a sub-verb and gives an example mapping, but it does not add deeper meaning beyond what the schema provides.

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

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

The description clearly identifies the tool as a threat-intelligence family dispatcher, names specific sub-verbs (candidateCdnApex, candidateMultiTenantApex, candidateSharedHostingIp), and provides a concrete example call. It is easily distinguished from sibling tools like whisper_identify 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 explains how to invoke the tool (pass a sub-verb and an input) and mentions that it works without an API key, but it does not explicitly state when to use this tool versus alternatives or what conditions make it the right choice. The no-API-key note is a usage condition, not a full selection guide.

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. The description adds the valuable behavioral detail that no API key is required, which is not in the annotations. It also states the ranking criterion and shows the input format, providing context beyond the structured data.

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 very short, front-loaded with the core purpose, followed by a usage note and an example. Every sentence carries useful information; there is no filler or redundancy.

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

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

For a simple single-parameter read-only query tool, the description is complete: it states the purpose, ranking criterion, example input, and auth requirement. No output schema exists, and none is necessary for such a straightforward query. Annotations cover safety, and the example removes any ambiguity about invocation.

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

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

The input schema already provides a full description of 'input' as a row limit, with the example passing 10. The description's example call repeats this information without adding new semantic meaning. With 100% schema coverage, 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 tool returns top ASNs ranked by announced-prefix count, with a specific verb and resource. It distinguishes itself from the sibling whisper_* tools, which have distinct names and purposes. The example call reinforces the purpose.

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

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

The description provides a concrete example call, which implies usage, and notes that answers require no API key. However, it gives no explicit when-to-use or when-not-to-use guidance relative to sibling tools. Usage is mostly implied rather than stated.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the meaningful behavioral fact that no API key is required, which is not in the annotations. It also provides a concrete example call, but does not detail output format or edge cases, so it earns a 4 rather than 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?

The description is two sentences plus an example call, with no verbose or redundant language. The core purpose is front-loaded, and every element (purpose, auth note, example) earns its place. Excellent for a simple tool.

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

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

For a single-parameter, read-only tool with no output schema, the description covers the purpose and usage, and the auth requirement. However, it does not clarify what 'variants/permutations' means in practice (e.g., typos, case changes, format conversions) or what the return structure looks like, leaving some ambiguity for correct invocation.

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

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

Schema description coverage is 100%, so the parameter type and accepted indicators (domain, IP, ASN, file hash) are fully documented in the schema. The tool description only repeats the example input without adding deeper semantics about what 'variants' means for each indicator type, so it does not exceed the baseline.

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

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

The description clearly states a specific verb ('Enumerate') and resource ('variants/permutations of an indicator'), which distinguishes it from sibling tools by its focus on generating alternate forms. The example call reinforces the purpose. It does not explicitly differentiate from siblings by name, but the unique action is evident.

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

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

The description implies usage when variant permutations are needed, and the note 'Answers without an API key' suggests a use case when no key is available. However, there is no explicit when-to-use or comparison with alternatives, leaving the agent to infer context from the name and example.

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, so the safety profile is covered. The description adds one useful non-annotation trait — 'Answers without an API key' (auth requirement). However, it doesn't disclose traversal limits (max hops), which relationship types are followed, or what a walk returns, which are meaningful behavioral traits for a graph-walking 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?

Three short sentences, each earning its place: purpose first, then the auth note, then a concrete example. The description is front-loaded with the purpose and wastes no words. Not quite a 5 because the example could arguably be merged or trimmed, but it's efficient and well-ordered.

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 low-complexity tool (1 param, no enums, no nested objects, full schema coverage, safety annotations), the description is largely adequate. The only gap is the return format of a walk — with no output schema present, an agent is left to guess what the traversal produces. This minor omission keeps it from a 5.

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 input parameter is fully documented in the schema (domain, IP, ASN, or file hash). The description adds a concrete example call ('example.com'), which is a minor bonus but adds no semantic meaning beyond what the schema already states. The baseline 3 is appropriate given full schema coverage.

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

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

The verb 'walk' plus 'graph from an indicator across its relationships' conveys a specific action (traverse relationships) on a specific resource (indicator graph). It distinguishes reasonably from siblings like whisper_identify (lookup) or whisper_explain (explanations) — 'walk' implies traversal. However, it never states what the output actually is (related indicators? paths? depth-limited results?), which leaves the purpose slightly underspecified.

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 and notes 'Answers without an API key,' which hints at accessibility, but it never explicitly states when to choose this tool over siblings that also explore relationships (e.g., whisper_origins, whisper_variants, whisper_history). There is no 'use this when...' or 'for X use sibling instead' 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 cover read-only/destructive hints. The description adds the useful behavioral fact that it 'Answers without an API key,' and implies ongoing observation over time. However, it does not disclose what happens during watching, whether it blocks, or what the output looks like.

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 sentences, front-loads the core purpose, and includes a concrete example call. Every sentence adds value, and there is no redundant content.

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

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

With a nested input object, no output schema, and no enumeration of actions, the description is incomplete for an agent trying to invoke the tool correctly. The single example helps but does not cover the range of possible operations or expected results.

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

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

The input schema only describes the top-level 'input' object, so the example call with {"action":"list"} adds some practical meaning. But the description does not explain possible actions or their semantics, leaving the nested parameter behavior largely undocumented.

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

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

The description states a clear verb and resource: 'Watch an indicator for change/activity over time.' This conveys the tool's monitoring purpose and distinguishes it from static lookup tools, though it does not explicitly differentiate it from sibling tools like whisper_walk.

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

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

The description gives no guidance on when to use this tool versus alternatives. It mentions 'Answers without an API key,' which hints at a usage condition, but there are no explicit when-to-use or when-not-to-use instructions, especially given the large set of sibling tools.

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