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

Annotations already declare write (readOnlyHint=false), non-destructive, and non-idempotent behavior. The description adds useful context that the artifact is private and hashed, but it does not address whether repeated calls duplicate evidence, whether content is retrievable, or any permission requirements.

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

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

A single, front-loaded sentence with no filler or redundancy. It is efficient, though its brevity contributes to the missing guidance noted elsewhere.

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 4-parameter write tool with 0% schema description coverage, the one-sentence description is incomplete. An output schema and safety annotations exist, but the description still omits parameter meaning and usage context that the agent needs to invoke it correctly.

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

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

Schema description coverage is 0% for 4 parameters. The description vaguely implies text content and a finding link but never names or explains finding_id, label, content, or the media_type enum, leaving all parameters semantically 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?

States a specific verb+resource ('Store a private, hashed text evidence artifact and link it to a finding'), making the evidence-attachment function clear. It does not name or contrast with siblings like create_finding or update_finding, so it falls short of full sibling 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 offers no when-to-use guidance, no prerequisites, and no alternatives. An agent must infer that this is the tool for attaching evidence rather than creating or updating a finding.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds two useful behavioral facts beyond them: the mode must be 'explicitly enabled' and results are filtered to in-scope subdomains. It still omits auth requirements, rate limits, or data-source behavior.

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

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

A single tight sentence with the action front-loaded and no filler. Appropriately sized for a one-parameter tool, though it leaves room that could have carried usage or parameter detail.

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

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

Complexity is low, an output schema exists so return values need no explanation, and annotations cover safety. What remains missing is the meaning of the 'domain' input and any routing against the competing discovery siblings, leaving the definition adequate but not complete.

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

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

One parameter at 0% schema coverage: 'domain' is typed but entirely undocumented in the schema. The description never states that this parameter is the target root domain to enumerate, so it fails to compensate for the coverage gap even for a single obvious-looking input.

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

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

States a specific verb and resource ('Run the explicitly enabled Amass passive enumeration mode') and adds the output scope ('retain only in-scope subdomains'). Naming Amass implicitly separates it from subfinder_discovery/assetfinder_discovery, but it never explicitly routes against subdomain_enumeration or dns_enumeration, so it stops short of full sibling 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 word 'passive' implies the when-to-use condition (non-intrusive enumeration with no direct target interaction), which is meaningful when choosing among the many subdomain-discovery siblings. However, no alternative is named and no explicit when/when-not rule is given, so the guidance remains 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, idempotentHint, non-destructive and closed-world, so the safety profile is fully covered. The description adds the content of the summary, but discloses nothing about cost, caching, scope of the rollup, or whether it reads live state versus stored findings.

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

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

One sentence, front-loaded with the verb, and the enumerated facets are tightly packed with no filler. Nothing could be removed without losing 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?

With an output schema present, return values need no prose explanation, and with zero parameters the call signature is unambiguous. The remaining gap is orientation within the toolset, which is a usage-guideline gap rather than a completeness one.

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

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

The tool takes zero parameters, so the baseline is 4. Schema coverage is nominally 100% but there is nothing to document; no parameter-level explanation is needed or missing.

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

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

States a specific verb (Summarize) and enumerates the resource facets covered: finding severity/status, targets, scope readiness, runtime metrics. This is clearer than a bare restatement of the title, but it never distinguishes itself from adjacent aggregation/reporting siblings such as list_findings or generate_vulnerability_report.

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

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

No when-to-use guidance, no prerequisites, and no named alternative. An agent cannot tell from the description whether this is a dashboard-style rollup to call before reporting or a duplicate of list_findings. The only implicit cue is the word 'Summarize'.

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, idempotentHint and destructiveHint, so the safety profile is covered. The description adds that an external binary must be 'explicitly enabled' and that results are scope-filtered, but says nothing about failure mode when the binary is absent or about rate/volume behavior for an open-world scan.

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

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

A single, front-loaded sentence with the verb first and zero wasted words. It is efficient, though its brevity tips toward under-specification rather than over-verbosity.

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

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

An output schema exists and annotations are rich, so return values and safety need no repeating. However, the missing usage routing against numerous subdomain-discovery siblings and the unexplained domain parameter leave real gaps for an agent choosing between tools.

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

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

Schema description coverage is 0% and the description never explains the single 'domain' parameter — whether it is the apex, a wildcard base, or which scope it maps to. With 0% coverage the description should compensate but instead adds no parameter meaning beyond the schema's own name.

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

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

States a specific verb ('Run') and resource ('Assetfinder binary') and clarifies output ('retain only in-scope subdomains'). Naming the specific binary distinguishes it from asset-based siblings, though it never explicitly frames this as subdomain discovery or contrasts it with subfinder_discovery/amass_passive_discovery.

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

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

The phrase 'explicitly enabled' hints at a precondition, but there is no guidance on when to choose Assetfinder over the many sibling subdomain tools (subfinder_discovery, amass_passive_discovery, subdomain_enumeration). No when/when-not or alternative routing is offered.

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

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

Annotations already cover read-only, idempotent, open-world and non-destructive traits, so the bar is lower; the description still adds real behavior beyond them: bounded concurrency, per-target error isolation (one failure doesn't abort the batch), and an authorization precondition. Redirect handling is not mentioned in the description but is defaulted in the schema.

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

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

A single front-loaded sentence with no filler; the batch limit, resource type, and error/concurrency behavior are all packed in 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?

An output schema exists so return values need no explanation, and annotations carry the safety profile. The description covers scope, concurrency, error semantics and auth, leaving only redirect behavior unaddressed (and that is defaulted in the schema), so it is nearly complete for a batch probe tool.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It adds 'HTTP(S)' item semantics and the authorization precondition for urls, but 'up to 20' merely restates maxItems and follow_redirects (default true) is never addressed in either schema or description.

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

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

Specific verb+resource ('Fetch metadata for ... HTTP(S) URLs') with batch scope made explicit by 'up to 20', which separates it from the single-target http_probe sibling. It stops short of naming the alternative, but an agent can identify it as the batch variant from the name and description alone.

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

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

Usage is implied rather than stated: the 'up to 20' batch framing suggests using this when multiple URLs must be probed, and 'authorized' signals a precondition. There is no explicit when-not guidance or pointer to http_probe for single-target cases.

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

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

Annotations already declare readOnly, idempotent, destructive=false, and openWorld=false, so the safety profile is covered. The description reinforces the offline nature and adds the 100-target ceiling, but adds nothing about how targets are canonicalized, whether input order is preserved, or how partial/invalid entries are handled.

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

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

A single front-loaded sentence with no padding, and the batch limit sits where a reader needs it. It is efficient, though the extreme terseness is part of why key semantics are missing rather than a stylistic strength.

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

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

An output schema exists, so return-value detail is not required. Still, for a one-parameter tool the agent lacks the core notion of what 'evaluate' resolves to and how this differs from the non-batch 'scope_check' sibling, leaving a real gap despite the simple shape.

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

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

Schema description coverage is 0% for the single 'targets' parameter, so the description must compensate. It supplies the useful 100-item bound, but never says what a target looks like (domain, URL, CIDR, wildcard) or what canonicalization is applied, leaving the element format undocumented in both places.

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

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

The verb pair 'canonicalize and evaluate' plus the resource 'targets' gives a rough sense of the operation, and the 100-item cap matches the schema. However, it never states what the evaluation decides (e.g., in-scope vs out-of-scope) or that it is the batch counterpart of the sibling 'scope_check', so the agent must infer the purpose from the name.

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

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

'Without network activity' implies a local/offline check, which is a weak contextual hint. There is no explicit when-to-use guidance, no condition for choosing this over the sibling 'scope_check', and no stated prerequisites such as where the scope rules come from.

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, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered. The description's only additions are the 'one authorized response' constraint and the sensitive-path caching scope, which are mildly useful but say nothing about live-request behavior, rate limits, or what 'authorized' implies operationally.

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

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

A single 20-word sentence with zero filler, and the analysis scope is front-loaded right after the verb. It packs five facets into one list, which is dense but not padded.

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

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

An output schema exists, so return values need not be described, and annotations fully cover the safety profile; with only one parameter, the definition is nearly complete. The remaining gap is routing guidance against the many overlapping header/cookie/CORS analysis siblings, which the description does not address.

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

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

Schema description coverage is 0% for the single required 'url' parameter, so the description must compensate. 'on one authorized response' hints that the URL targets a single HTTP response and that the caller must be authorized to test it, but there is no guidance on URL format, absolute vs. relative, or the 2048-char limit.

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

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

States a specific verb ('Assess') and a specific resource ('Cache-Control, Vary, validators, CDN signals, and sensitive-path caching'), which pins down the scope far better than the generic title 'Analyze HTTP cache policy'. It implicitly separates itself from broad siblings like headers_analysis by naming cache-specific facets, but it never names an alternative tool outright.

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

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

The phrase 'on one authorized response' communicates the operating scope (single response, authorization required), which is real usage context. However, there is no explicit when-to-use guidance, no exclusions, and no pointer to the overlapping siblings such as headers_analysis or cookie_security_analysis, so the agent must infer when this is the right 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 cover safety (readOnlyHint, openWorldHint=false, idempotentHint, destructiveHint=false). The description adds real value beyond them with 'without accessing them', telling the agent the references are extracted statically rather than fetched or validated.

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

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

One sentence, front-loaded with the verb, no filler, and the most important qualifier ('without accessing them') placed at the end without bloat.

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

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

An output schema exists, so return values need not be explained, and the tool is a simple 1-param static extractor. The description is nearly sufficient, though it could say more about what the input text should contain.

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

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

Schema description coverage is 0% and the single content parameter is undocumented in the schema. The phrase 'from supplied text' weakly maps to it, but no format, size, or encoding guidance is given — marginal compensation for the gap.

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

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

Specific verb (Extract) plus the exact resource classes (AWS S3, GCS, Azure Blob, Firebase references) and the scope (from supplied text). This clearly separates it from siblings like secret_pattern_analysis or url_parameter_analysis.

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

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

Usage is implied by 'from supplied text', but there is no explicit when-to-use guidance and no routing to or away from alternatives such as secret_pattern_analysis. An agent can infer the context, but nothing is 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?

The annotation already declares readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, meaning the agent knows this is a safe, idempotent, read-only operation. The description adds the useful security constraint of not sending auth material, which is valuable context for a security scanning tool. However, it doesn't disclose rate limits, redirect behavior, or other operational traits beyond that constraint. With annotations covering the safety profile well, 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?

A single, efficient sentence that front-loads the core purpose. 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?

While annotations cover the safety profile and there's an output schema (so return values need not be explained), the description doesn't mention prerequisites (e.g., URL must be reachable), what cookies it inspects (session cookies, tracking cookies?), or any operational details. For a security auditing tool, more could be said about when it's appropriate to use within an assessment workflow.

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

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

Schema description coverage is 0%, so the description would ideally explain the 'url' parameter. It only mentions 'without sending authentication material', which doesn't clarify the URL parameter's meaning or format beyond what the schema's type and constraints provide. Baseline 3 is appropriate since there's only one parameter and the description adds minimal parameter-specific information.

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

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

States a specific verb ('Inspect') and resource ('Set-Cookie attributes'), which is clear. It doesn't explicitly differentiate from siblings like headers_analysis or csp_analysis, but the resource specificity makes the target 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?

There's implicit guidance via 'without sending authentication material' but no explicit when-to-use versus alternatives like headers_analysis. The usage context is implied rather than stated.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds that probes are 'bounded', hinting at limited request volume, but says nothing about authentication needs, rate limits, or what makes a response count as 'permissive'.

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

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

A single sentence with the action and outcome front-loaded and no filler. It is efficient, though its brevity leaves little room for otherwise-needed usage and parameter detail.

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

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

An output schema exists, so return values need not be described. However, with 0% parameter coverage and no usage guidance, this definition omits information an agent needs to invoke a two-parameter security scanner correctly.

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

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

Schema description coverage is 0% for two parameters (url, origins), so the description carries the full explanatory burden — and it does not. 'Cross-origin probes' loosely gestures at the origins parameter but the description never explains the url target, the max-5 origins list, or their formats.

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 pairs a specific verb ('send... probes', 'identify') with a specific resource ('permissive CORS responses'), so the tool's job is unambiguous. It is naturally distinct from siblings like csp_analysis or headers_analysis, though it never explicitly names or contrasts them.

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

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

There is no when-to-use, when-not-to-use, or alternative guidance. An agent cannot tell from the text whether this is a first-pass recon step or a deep-dive that presupposes prior discovery, nor how it relates to sibling security analyzers.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=false, and idempotentHint=false, so the safety and locality profile is covered. The description reinforces the write-to-local-store nature, which is slightly useful, but adds nothing about validation failures, duplicate handling, or what a successful persist returns.

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

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

The single front-loaded sentence is clean and waste-free, but for a 14-parameter creation tool it is under-sized rather than appropriately concise. Every word earns its place, yet there are too few words for the tool's complexity.

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

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

An output schema exists, so return values need not be explained, but the description omits the required fields (title, severity, target, description), the CWE/CVSS conventions, and how this tool relates to add_finding_evidence and update_finding. Given 14 undocumented parameters and a rich sibling set, this leaves large 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?

The schema has 14 parameters with 0% description coverage, and the description contributes no parameter meaning whatsoever. For a 14-param creation tool the description is expected to compensate for the bare schema, and it fails to do so.

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 (persist) and resource (a structured security finding) plus its destination (local finding store), so an agent knows this writes a new finding record rather than reading or updating one. It does not explicitly name siblings like add_finding_evidence or update_finding, so an agent must infer the boundary from names alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternatives (add_finding_evidence for attaching evidence, update_finding for edits, list_findings for reads). The agent is left to infer the workflow position of this tool entirely.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds value by disclosing an authorization requirement and enumerating the classes of findings produced, which goes beyond the structured fields.

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

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

A single front-loaded sentence with the action first and the analysis dimensions second; every clause carries information and nothing is padded.

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 rich annotation set and an output schema (so return values need not be explained), the description is nearly sufficient for correct invocation; the only gap is the absence of guidance on sibling selection.

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

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

One parameter with 0% schema description coverage, so the schema documents only type and length constraints. The description implies the url is a live endpoint to be fetched and must be authorized, adding modest meaning, but no format or scope syntax is given.

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

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

Specific verb (Fetch, assess) plus resource (CSP directives) with the exact analysis dimensions (unsafe, missing, duplicate, deprecated). An agent can distinguish it from general header tools, though it never names the closest sibling (headers_analysis) explicitly.

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

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

Only implied usage: 'an authorized endpoint' hints that the target must be in-scope and permitted, but there is no statement of when to pick this over headers_analysis or scope_check, and no preconditions or 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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety and determinism profile is covered. The description's 'locally' largely restates openWorldHint=false, but 'Validate' adds the useful behavioral signal that malformed vectors are rejected rather than silently scored. No detail on error behavior beyond 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?

One sentence, front-loaded with the action and resource, and every clause carries information (validation, outputs, local execution). Nothing redundant or padded.

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

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

An output schema exists, so return values need not be explained, and the description plus annotations cover the core contract for a single-argument pure function. The remaining gap is the input vector format/validation rules, which the agent must infer.

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

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

Schema coverage is 0% — the single 'vector' parameter is an undocumented 1-200 char string. The description compensates by identifying it as a 'CVSS v3.1 base vector', which tells the agent the expected format family, but gives no example syntax or mention of accepted prefixes/ordering.

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

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

Names a specific verb pair (validate, calculate) and a precise resource (CVSS v3.1 base vector) plus the outputs produced (score, rating, impact, exploitability). No sibling tool in the list performs scoring math, so the agent can distinguish this from the scanning/reporting tools without opening the schema.

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

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

The purpose implies when to use it (turning a given vector into a score during triage/reporting), and 'locally' signals no external lookup is needed. However, it never states when NOT to use it, whether it accepts only base metrics versus temporal/environmental vectors, or how it relates to finding/report 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 readOnly, idempotent, non-destructive and openWorld, so the safety profile is largely handled. The description adds genuinely useful behavioral context beyond that: results are unresolved-alias 'indicators' rather than confirmed findings, and they require manual verification, which shapes how an agent should interpret and act on the output.

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

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

One sentence, front-loaded with the action and resource, followed immediately by the output interpretation. No filler, no redundancy with the title or annotations.

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

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

With an output schema present, the description need not explain return values, and annotations already carry the safety profile. It conveys purpose, output meaning, and the manual-verification caveat; the main residual gap is the input domain semantics, which is left entirely to the schema.

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

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

The single `domain` parameter has 0% schema description coverage, and the description never clarifies whether it expects an apex domain or a specific hostname, nor whether CNAME chains are followed. The only hint is the mention of 'CNAME targets', which does not meaningfully compensate for the schema gap.

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

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

States a specific verb (inspect) and resource (CNAME targets / dangling DNS aliases) and names the class of output (unresolved aliases as takeover indicators). It is clearly distinguishable from generic siblings like dns_enumeration or wildcard_dns_analysis by focusing on subdomain-takeover detection, though it does not name any sibling explicitly.

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

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

The phrase 'takeover indicators requiring manual verification' implies a security-assessment use case, so an agent can infer when this tool fits. However, there is no explicit when-to-use guidance, no stated prerequisites, and no pointer to how this differs from dns_enumeration or wildcard_dns_analysis, which an agent choosing between DNS tools would need.

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, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered structurally. The description adds only the authorization-scope context ('authorized domain'); it says nothing about per-type failure behavior, rate limits, or partial results, which is a modest contribution.

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

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

A single front-loaded sentence with no filler or redundancy. Efficient, though its brevity is partly the cause of the semantic gaps noted elsewhere.

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

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

An output schema exists, so return format need not be explained, and annotations cover the safety profile. Still, for a tool with 0% schema description coverage and numerous close siblings, the description does not supply enough scope or usage detail to fully orient the agent.

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

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

Schema description coverage is 0%, so the description carries the full burden. It names the domain and hints at selectable record types but adds no format, syntax, or constraint detail (e.g., the 8-type maximum, uniqueness, or what happens when record_types is omitted), only nominally overlapping the schema's own field names.

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

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

States a specific verb (Resolve) and resource (DNS record types) with a clear scope constraint ('one authorized domain'). However, it does not distinguish itself from the many DNS-adjacent siblings such as dnssec_posture_analysis, wildcard_dns_analysis, or dangling_dns_analysis, leaving the agent to infer the boundary.

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

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

The phrase 'for one authorized domain' implies an authorization prerequisite but gives no explicit when-to-use guidance, no exclusions, and no routing to alternative DNS tools. The agent must guess when general record enumeration is preferable to the specialized DNS siblings.

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

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

Annotations already cover the safety profile (read-only, idempotent, non-destructive, open-world), so the description earns credit for the one thing they cannot express: the explicit limitation that it does not perform full resolver validation, which prevents the agent over-claiming a validating-resolver result. It still omits anything about rate limits, resolver selection, or failure modes on unsigned zones.

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

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

One sentence, front-loaded with the action and the inspected record types, ending with the scope caveat. Every clause carries information and nothing is padded.

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 rich annotation set and an output schema, the description only needs to define scope and limits, which it largely does; the 'no full resolver validation' caveat closes the biggest risk of misinterpretation. The remaining gap is the missing prerequisite/routing to scope_check for the 'authorized domain' claim.

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

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

Schema description coverage is 0% for the single 'domain' parameter, so the description must carry the meaning; 'for an authorized domain' implies an authorization/scope prerequisite that the bare string schema does not convey. That is useful but thin, and no format, zone-apex, or subdomain expectations are given.

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

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

States a specific verb (inspect) and the exact record types examined (DNSKEY, DS, RRSIG), which is far more precise than the generic 'DNSSEC posture' title and cleanly separates it from dns_enumeration or email_security_analysis. It does not name a sibling tool or explicitly contrast scope, so it stops short of a 5.

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

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

There is no statement of when to run this versus alternatives (ssl_scan, email_security_analysis, dns_enumeration), nor any when-not condition. The only usage signal is the implicit 'authorized domain' prerequisite, which hints at a scope check but never tells the agent to perform one.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds genuinely non-obvious context: the output is a bounded candidate list and no DNS resolution or network contact occurs, which prevents an agent from expecting live-verified results.

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

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

A single front-loaded sentence with no filler; the core action and its two key constraints (authorized scope, no resolution) come before any elaboration.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. The description addresses purpose and the critical non-contact behavior, leaving only parameter semantics (notably 'maximum') as a gap for an otherwise simple two-parameter tool.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning and does not. 'Bounded' faintly gestures at the 'maximum' parameter but gives no range, default, or effect, and nothing explains the accepted form of 'domain' (single hostname vs. with scheme/subdomain).

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

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

States a specific verb and resource ('Generate ... candidate list') plus the output character ('typo-oriented'), the scope ('one authorized domain'), and the boundary ('bounded'). This clearly separates it from siblings like dns_enumeration and subdomain_enumeration, which discover real assets rather than synthesizing typo candidates.

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?

'for one authorized domain' implies an authorization precondition, and the no-resolve/no-contact clause hints at how results are meant to be consumed, but there is no explicit when-to-use, when-not, or named follow-up alternative. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so safety and repeatability are covered without description help. The description adds the meaningful precondition that the domain must be authorized, plus the scope of records examined, but says nothing about rate limits, external lookups, or what an empty/misconfigured record set returns.

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

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

One sentence, front-loaded with the verb and the record set, with zero filler. Every clause earns its place and nothing is buried.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. What is missing is routing context among the many DNS/security siblings and any expectation-setting about what the audit produces, leaving the definition adequate but not complete.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It implies the single input is a domain name and flags that it must be an authorized one, but gives no format guidance (bare apex vs subdomain, IDN/punycode, trailing dot). For a single self-evident parameter this is minimally adequate.

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 ('Inspect') and an enumerated resource set (MX, SPF, DMARC, MTA-STS, SMTP TLS reporting records), which cleanly separates it from network/DNS siblings like dns_enumeration or dnssec_posture_analysis. An agent knows exactly what class of check this performs without opening the schema.

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

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

There is no explicit guidance on when to choose this tool over alternatives such as dns_enumeration or security_txt_analysis, and no when-not conditions. The only usage signal is the implicit 'authorized domain' precondition, which is a constraint rather than 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 read-only, idempotent, non-destructive, open-world, so the safety profile is covered. The description adds real behavioral value on top: the fetch is constrained to the same scope, and the response deliberately contains derived hashes and metadata rather than image bytes, which tells the agent how to treat the result.

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

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

A single compact sentence that front-loads the action and ends with the constraint that matters most (no image bytes). No filler, no restatement of the name or title.

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

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

An output schema exists, so return values need not be spelled out, and annotations cover the safety profile. The definition is nearly complete for a one-parameter read tool; only the expected form of 'url' and the behavior when no same-scope favicon is found remain unspecified.

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?

One parameter with 0% schema description coverage, so the description has to carry the load. It hints at input semantics by saying 'discovered or conventional', suggesting the tool will fall back to well-known favicon locations, but it never says whether 'url' is the page URL or the direct favicon file URL, leaving the most important ambiguity unresolved.

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

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

Specific verb (fetch/fingerprint) plus resource (favicon) plus scope (same-scope) and a stated output shape (stable hashes and metadata, never image bytes). Nothing else in the sibling list fingerprints favicons, so confusion is unlikely, though no sibling is named or contrasted explicitly.

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

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

'Discovered or conventional' implies the two cases in which it is used (a URL already found on a page, or a conventional path), which is useful context. But it never states when to prefer this over technology_fingerprint or web_metadata_discovery, nor any preconditions or failure behavior.

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, idempotentHint, openWorldHint, and non-destructiveness, so safety is covered. The description adds that results are filtered to 'authorized HTTP(S) URLs,' which is useful scope-limiting context, but it says nothing about rate limits, the archive-enabled precondition, or result volume.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity contributes to the gaps in usage and parameter coverage rather than a structural flaw being 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 an output schema present, return values need not be explained, and annotations carry the safety profile. Still, the 0% parameter coverage and absent usage guidance leave material gaps for a tool whose behavior depends on a provider selection the description never mentions.

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

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

Schema description coverage is 0% and the description explains neither 'domain' nor 'providers' (wayback/commoncrawl/otx/urlscan). With two undocumented parameters and no compensating text, the agent gets no semantic guidance on what values are valid or what the provider selection controls.

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

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

The description gives a clear verb ('Run') and resource ('gau archive discovery binary'), specifying it discovers URLs from archives and returns HTTP(S) URLs. However, it offers no differentiation from sibling discovery tools like subfinder_discovery, amass_passive_discovery, or assetfinder_discovery, leaving the agent to infer the passive-archive versus passive-DNS distinction.

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

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

There is no explicit when-to-use guidance, no when-not-to-use, and no named alternatives. The phrase 'explicitly enabled' hints at a configuration prerequisite but never explains it, so the agent cannot tell under what conditions this tool is appropriate versus other discovery siblings.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=false, so the agent knows this is a state-touching but non-destructive operation. The description adds only the format list and SARIF version; it says nothing about whether an artifact is written, where it goes, or whether the target scopes the export. It adds some value but not rich behavioral context beyond 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?

A single tight sentence with the core action and output formats front-loaded. Nothing is wasted, though the extreme brevity leaves room it could have used for the undocumented target parameter.

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

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

An output schema exists, so return-value explanation is not required. However, for a tool whose 'target' parameter is undefined and whose usage timing is unstated, the description is only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly covers report_format by naming the four output formats, but says nothing about the 'target' parameter, which is completely undocumented in both the schema and the description. Half the parameters remain opaque.

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

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

The description states a specific verb (Export) and resource (current findings), and enumerates the output formats, so the agent knows exactly what the tool produces. It does not explicitly distinguish itself from siblings like list_findings or assessment_summary, but the report-generation purpose is unmistakable.

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

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

There is no guidance on when to invoke this tool versus alternatives such as list_findings, assessment_summary, or the individual analysis tools. It never says whether it should be run after a scan completes, or how format choice should be decided.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety bar is low. The description still adds value beyond them: probes are 'bounded', restricted to same-origin paths, and introspection is described as optional and read-only, which tells the agent about scope and limits.

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

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

A single dense sentence with no filler; the probing mechanism and the same-origin constraint are front-loaded. It is efficient, though the semicolon clause somewhat crowds the core action.

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

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

An output schema exists so return values need no explanation, and annotations cover the safety profile. The description supplies mechanism, origin scope, and introspection behavior, leaving only minor gaps around default paths and parameter interaction.

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

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

Schema description coverage is 0%, so the description must compensate for three undocumented parameters. It partially does: 'conventional or supplied ... paths' explains the paths array versus default discovery, and 'optional introspection checks' maps to check_introspection, but it never clarifies the url vs paths relationship or the full 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 names a specific verb and mechanism ('Send bounded read-only __typename probes to ... paths') and identifies the resource as GraphQL endpoints, so an agent can distinguish it from generic crawlers. It does not name which sibling it supersedes (e.g. openapi_discovery, javascript_endpoint_discovery), so it stops short of 5.

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

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

There is no explicit when-to-use or when-not guidance, and no mention of alternatives among the many discovery siblings (openapi_discovery, javascript_endpoint_discovery, source_map_discovery). 'Conventional or supplied same-origin paths' hints at the operating mode but does not route the agent between 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, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds the word 'authorized,' implying a permission/authorization prerequisite, but says nothing about rate limits, which headers are examined, or any destructive-free guarantees beyond the annotation.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity reflects under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. However, with 0% parameter coverage and no usage routing among many header-related siblings, the description is only minimally complete for an audit tool.

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

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

Schema description coverage is 0% and the single 'url' parameter has no description, so the schema does not carry the burden. The description partially compensates by implying exactly one authorized HTTP endpoint, but adds no format, scheme, or validation detail 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 (Analyze) and resource (security and disclosure headers) scoped to a single HTTP endpoint, so the agent knows the core action. It does not differentiate from overlapping siblings such as csp_analysis, cors_scan, or cookie_security_analysis, which also operate on response headers.

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

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

There is no explicit when-to-use guidance, no mention of alternatives, and no exclusions. The phrase 'on one authorized HTTP endpoint' hints at a single-URL scope but leaves the agent to infer when this tool is preferable to http_probe or the header-specific siblings.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds real context beyond them: it is exactly one OPTIONS request and deliberately avoids state-changing methods, which tells the agent this is a lightweight, low-impact probe.

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

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

A single front-loaded sentence with no filler; the mechanism and safety constraint both earn their 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?

An output schema exists, so return values need no explanation, and annotations cover safety. The definition is complete enough for a one-parameter read-only probe, with only the undocumented url parameter as 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?

Schema description coverage is 0% and the single required 'url' parameter is not described in text at all. The description says 'Send one OPTIONS request' but does not clarify expected URL format, scope, or constraints, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource: sends an OPTIONS request and assesses advertised HTTP methods. The mechanism is unique among siblings (http_probe, headers_analysis), so an agent can distinguish it functionally, though no sibling is named explicitly.

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

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

The phrase 'without attempting state-changing methods' implies a safe enumeration context, but there is no explicit when-to-use, when-not, or named alternative among the many sibling scanning tools. Usage is implied rather than directed.

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 declare read-only, idempotent, non-destructive and open-world, but the description adds real value beyond them: bounded redirects, bounded body size, and that only metadata is returned. It does not mention auth requirements or rate limits, but the bounding constraints are meaningful behavioral disclosure.

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

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

One sentence, front-loaded with the verb and resource, with the two most consequential constraints (redirects, body size) and the return-shape caveat packed in tightly. No waste.

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

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

An output schema exists, so return values needn't be detailed, and annotations cover the safety profile. The main gap is parameter documentation, which the description only partially addresses. Given the structured fields available, the description is nearly complete.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does: 'bounded redirects' explains follow_redirects, and 'not body data' implies HEAD/GET metadata behavior, but url format and method semantics are left undocumented. Partial compensation, not full 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?

States a specific verb (Fetch) and resource (one authorized URL) plus the distinctive behavior (returns metadata, not body data). Clear enough to distinguish from web_crawler and headers_analysis, though it does not explicitly name a sibling like batch_http_probe.

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 word 'authorized' implies a scoped/safety context and 'one URL' hints at the batch alternative, but no explicit when-to-use or when-not-to-use guidance is given and no sibling is named. An agent must infer the routing.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior. The description adds real context beyond that: only a 'bounded' set of scripts is fetched, only 'same-scope' scripts are followed, and 'literal' references imply static inspection rather than runtime execution. It stops short of stating limits, auth needs, or rate behavior.

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

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

A single sentence that front-loads the target and packs scope, bounding, and extraction type without any filler. Nothing could be removed without losing signal.

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

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

An output schema exists, so return values need not be described, and annotations carry the safety profile. The description covers the scope/bounding constraints, leaving only minor gaps such as whether JavaScript is executed and any authentication prerequisites for the authorized target.

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

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

Schema coverage is 0%, so the schema documents neither 'url' nor 'max_scripts'. The description partially compensates by indicating the url is a single authorized page/script and that the script set is bounded, which hints at what max_scripts controls. It gives no syntax, defaults, or ceiling details, so the gap is only partly filled.

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

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

The description gives a specific verb (inspect) and resource (a page or script plus same-scope scripts) scoped to extracting 'literal URL and path references.' That distinguishes it from siblings like web_crawler or gau_url_discovery, though it does not name any alternative explicitly.

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

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

Usage is implied by 'one authorized page or script' — it signals a single-target, in-scope inspection — but there is no explicit when-to-use or when-not-to-use guidance, and no routing to alternatives such as source_map_discovery or graphql_endpoint_discovery that also surface endpoints.

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=false, idempotentHint=true and destructiveHint=false, so the safety and locality profile is largely covered. The description still adds genuine value by reinforcing that decoding happens 'locally' and by disclosing the limitation that no signature verification occurs — a behavioral trait the annotations do not convey.

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

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

A single sentence carrying what it does, where it runs, what it flags, and its one hard limitation. Zero filler, correctly 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?

An output schema exists, so return-value explanation is rightly omitted, and the description covers purpose plus the critical non-verification caveat for a one-parameter tool. The only shortfall is the unaddressed input format, which is minor given the simple 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 0% for the single jwt_token parameter, so the description would need to compensate and it does not — it never states whether the expected input is a raw compact JWT, a full 'Bearer ...' header value, or a base64 segment. The parameter name is largely self-explanatory, which keeps this from scoring lower, but a real format ambiguity remains.

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

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

The description gives a concrete verb and resource ('Decode JWT metadata') plus the specific checks performed ('flag unsafe algorithms or claim timing'), and explicitly states the scope boundary ('does not verify a signature'). No sibling tool performs JWT analysis, and an agent can immediately tell what this tool produces versus the DNS/HTTP/scanning tools around it.

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 clause 'does not verify a signature' usefully rules out one misuse case, but the description never states when an agent should reach for this tool or name any alternative. Usage is implied (analyze a JWT you already have) rather than guided, which lands at the minimum-viable level.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered structurally. The description adds the useful fact that findings are 'locally persisted' (i.e., a local store, not a remote fetch), but says nothing about pagination, ordering, or result limits.

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

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

A single well-formed sentence with the object of the operation front-loaded and no filler. It is efficient, though at the cost of leaving filters and scope entirely unspecified.

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

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

An output schema exists, so return values need not be described, and annotations carry the safety profile. However, for a retrieval tool with three undocumented filter parameters, the description leaves the agent guessing about what can be filtered and in what form, which is a meaningful 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 0% across 3 parameters, so the description must compensate and it does not — it only says 'optional filters' without naming status, target, or severity. The two enum parameters are partially self-documenting via their allowed values, but 'target' has neither a schema description nor any hint from the description.

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

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

Clear verb+resource: 'List locally persisted findings'. The qualifier 'locally persisted' distinguishes it from network-scanning siblings and implies reading the findings store. It does not, however, explicitly differentiate from create_finding/update_finding vs. this read path, though the verb makes the distinction fairly 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as create_finding or update_finding for the write side. The 'optional filters' phrase implies a filtered retrieval context but never states when an agent should prefer this over other finding-related 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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful context beyond that – a locally installed binary is required and the tool is gated behind an explicit-enable flag – but says nothing about scan duration, rate limits, or what the scan actually issues against the target. Adequate, not rich.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity is partly achieved by omitting information the agent needs rather than by tight writing.

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

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

An output schema exists so return values need not be described, and the safety annotations are good. However, for a three-parameter active scanner with 0% schema coverage, the description omits parameter meaning, scan scope/duration expectations, and any routing guidance among the many sibling scanners – too thin for the tool's complexity.

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

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

Schema description coverage is 0%, so the description carries the full burden. It only gestures at the required "target" argument via "one authorized target" and adds nothing about the tags or severity filters, which are the parameters an agent most needs explained (accepted syntax, template selection, severity values).

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

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

States a specific verb and resource ("Run the locally installed Nuclei scanner") plus a scope constraint ("one authorized target"), which distinguishes it from template-less siblings like http_probe or web_directory_scan. It stops short of explicitly naming when another scanner is the better pick, so it is clear but not sibling-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?

"when explicitly enabled" implies a precondition (the scanner must be turned on/authorized) but never says when to choose Nuclei over other scan tools such as cors_scan, secret_pattern_analysis, or web_directory_scan. Usage is implied rather than stated; no exclusions or alternatives are given.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, covering the safety profile. The description usefully adds that probing is limited to conventional same-origin documents (not cross-origin or custom paths), which is real behavioral context, but says nothing about failure behavior when no document exists or about rate/network constraints.

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

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

One sentence with zero filler; the probing scope is front-loaded and the summarized outputs are appended compactly.

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

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

An output schema exists, so return values need no explanation. Still, with 0% schema description coverage and no discussion of target URL format or negative results, the definition leaves a small but real gap for a tool with one required input.

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

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

Schema description coverage is 0%, so the single 'url' parameter carries no schema-level documentation. The description partially compensates by implying the URL is an origin/base for same-origin document probing, but it never states whether a full URL or bare origin is expected.

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

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

States a specific verb ('probe') and resource ('conventional same-origin discovery documents') plus the summarized outputs (endpoints, grants, response types, PKCE). This distinguishes it from siblings like openapi_discovery and web_metadata_discovery, though it never names them explicitly.

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

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

Usage is only implied — an agent can infer you call it against a target to learn its OAuth/OIDC configuration, but there is no explicit when-to-use, no prerequisites, and no routing against the many sibling discovery 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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds one genuine behavioral trait beyond them: it summarizes rather than returns full document contents, and that probing is confined to a bounded path list. Useful but thin given an output schema exists.

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

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

A single front-loaded sentence with no filler. The core action and its output-limiting constraint both land immediately.

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

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

Annotations cover the safety profile and an output schema covers the return shape, so the description need not explain those. However, with 0% parameter descriptions and no usage routing among 50+ siblings, an agent still lacks context on what url should point to and when to reach for this tool.

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

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

Schema coverage is 0%, so the description must compensate. 'Bounded list of conventional paths' partially explains the paths array (constrained to maxItems 10 by the schema), but the url parameter's role as the target base is never clarified and no path format examples are given.

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

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

States a specific verb+resource: probes conventional paths and summarizes OpenAPI/Swagger documents. It is clearly distinct from the security-focused openapi_security_analysis in intent, though it never names that sibling, so the differentiation is implicit rather than explicit.

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

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

No when-to-use or when-not guidance is given. An agent must infer that this is a discovery step preceding openapi_security_analysis, and there is no mention of prerequisites, target types, or alternatives among the many siblings.

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

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

Annotations cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint=false), so the description's 'Analyze supplied' adds little beyond confirming it operates on caller-provided input. It does not disclose the 'alias-free YAML' restriction's operational consequences or any output behavior, but with annotations carrying the burden 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?

Single efficient sentence, front-loaded with the target artifact and then the analysis dimensions. No filler or repetition of the tool name.

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

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

With only 2 parameters, an output schema present, and full annotation coverage, the bar is lower, but the 'alias-free' constraint is unexplained and no guidance on input size or format selection is offered. The description is adequate but not complete for an agent needing to prepare the document argument.

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

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

Schema description coverage is 0%, so the description must compensate but only partially succeeds: 'JSON or alias-free YAML' gives format context that maps to document_format, yet the required 'document' parameter, its maxLength of 1M chars, and the 'auto' default are not clarified. The enum values and defaults are left to the schema, which does document them structurally even without prose descriptions.

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

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

States a specific verb ('Analyze') and resource ('supplied JSON or alias-free YAML') and enumerates the exact outputs it looks for: operations, authentication coverage, deprecated endpoints, and security signals. The 'alias-free' qualifier is a precise constraint that distinguishes it from a generic document parser.

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 ('supplied' document) but does not state when to use this vs. openapi_discovery, which is the obvious sibling that also deals with OpenAPI. No exclusions or prerequisites are given, leaving the agent to infer that discovery finds specs while this one analyzes them.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds two useful facts beyond that: the scan is 'bounded' and limited to 'one authorized host'. It says nothing about rate limits, timeouts, default port range, or what happens on an unauthorized target.

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

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

A single front-loaded sentence with zero filler and no repetition of the title. It is efficient, though the terseness borders on under-specification rather than tight editing.

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

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

An output schema exists, so return values need not be described. However, for an open-world network scan with a 50%-covered schema, the description omits defaults for the optional 'ports' parameter and any operational caveats (timeouts, throttling), leaving the agent with an incomplete operational picture.

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?

Coverage is 50%: the 'ports' schema description already supplies the comma-separated range syntax and an example, while 'target' has no schema description at all. The phrase 'one authorized host' does clarify that target is a single host rather than a list, adding a little meaning, but it does not compensate for the undocumented 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 gives a specific verb and resource: a 'TCP connect scan' (as opposed to SYN or UDP) against a host. It implicitly separates itself from siblings like ssl_scan or http_probe by naming the scan technique, though it never names a sibling explicitly.

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

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

Usage is implied rather than stated: 'one authorized host' signals the single-target, permissioned context, but there is no guidance on when to prefer this over ssl_scan, http_probe, or http_method_analysis, nor any explicit exclusion. Adequate but with a clear gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds meaningful context beyond that: it fetches and summarizes only, explicitly avoiding crawling the disclosed paths, which tells the agent this is a passive read.

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

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

A single well-formed sentence with the core action front-loaded and zero filler. Every clause (RFC 9309, authorized origin, no path crawling) carries weight.

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

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

With an output schema present, return values need not be explained, and the annotations carry the safety profile. The definition is nearly complete for a one-parameter fetch tool; only the url input format is left unaddressed.

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

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

Schema coverage is 0% for the single url parameter, and the description adds only marginal meaning by implying the input is an 'authorized origin' (scheme+host). It offers no format, normalization, or scheme guidance for the url 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?

States a specific verb ('Fetch and summarize') and resource ('robots.txt file'), scoped by the RFC 9309 reference. It is clearly distinct from siblings like sitemap_analysis or security_txt_analysis, though it never names an alternative to differentiate explicitly.

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

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

The phrase 'without crawling disclosed paths' implies the tool reads and parses robots.txt rather than following it, which is a useful behavioral signal. However, there is no explicit when-to-use vs when-to-use-an-alternative guidance or prerequisite statement.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description still adds genuine value beyond them: 'performs no network request' tells the agent this is purely local decision logic with no outbound traffic or side effects, which matters in a security-assessment context, and 'explain' signals a reasoned response rather than a bare boolean.

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

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

One compact sentence with the primary function front-loaded and no filler. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety semantics. However, the accepted target format and the choice between this tool and batch_scope_check are left unaddressed, which are real gaps for a gating tool.

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

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

Schema description coverage is 0% and the description never mentions the single required 'target' parameter, so it does not clarify whether a target may be a hostname, URL, IP, or CIDR range. With low schema coverage, the description should compensate but adds nothing here.

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

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

States a specific verb pair ('validate and explain') and the resource ('target' authorization), so the agent knows exactly what the tool determines. It does not differentiate itself from the sibling batch_scope_check, leaving the single-vs-batch distinction to be inferred.

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

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

There is no when-to-use guidance, no prerequisite statement, and no named alternative such as batch_scope_check for multiple targets. The pre-scan gating role is only weakly implied by the word 'authorized'.

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=false, idempotentHint and destructiveHint=false, so the safe-read profile is covered. The description still adds value beyond that by disclosing that the analysis happens locally and that output is redacted fingerprints/ranges rather than raw secrets, which matters for handling sensitive 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?

A single front-loaded sentence with no padding; the scope ('locally') and the output guarantee ('only redacted fingerprints and locations') are both delivered immediately.

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

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

An output schema exists, so return values need not be spelled out, and annotations carry the safety profile. The remaining minor gap is which credential families are covered and any stated limits on large inputs, but for a one-parameter local analyzer this is close to complete.

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

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

Only one parameter, and the schema gives it 0% description coverage (no description on 'content', only min/max length constraints). 'Supplied text' reasonably identifies the parameter's meaning, so the description partially compensates, but adds no format, encoding, or size guidance.

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

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

Specific verb (inspect) plus resource (supplied text for credential formats) and a clear statement of output shape (redacted fingerprints and locations). It naturally separates from siblings like sensitive_file_exposure_scan or jwt_security_test, though it never names an alternative to sharpen the distinction.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. 'Supplied text locally' hints at the input domain, but an agent is left to infer on its own whether this or sensitive_file_exposure_scan / jwt_security_test is the right call for a given artifact.

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, idempotentHint and destructiveHint=false, so safety and idempotency are covered. The description adds one piece of non-annotation context, the 'authorized origin' scope constraint, which is useful. It does not explain behavior when the file is absent or malformed, so it only modestly exceeds the annotation baseline.

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

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

A single front-loaded sentence with the verb, resource and standard up front and no wasted clauses. Nothing to trim.

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

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

An output schema exists, so return values can be omitted, and the annotations cover the safety profile. However, the definition leaves the caller without usage context and without url formatting guidance, which is the remaining gap for a one-parameter discovery tool.

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

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

Schema description coverage is 0% for the single url parameter, so the description must compensate. It does add one meaningful hint, that the target is an origin rather than a path to security.txt, but provides no format, scheme, or normalization details. Partial compensation for the coverage gap.

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

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

Specific verbs (discover, validate) plus a precise resource (RFC 9116 security.txt metadata), so the agent knows exactly what is produced. It does not distinguish itself from adjacent sibling tools like robots_txt_analysis or sitemap_analysis, which follow the same discovery pattern.

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

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

No when-to-use or when-not-to-use guidance and no named alternative. The phrase 'authorized origin' implicitly signals the scope prerequisite, but the agent gets no signal about when this audit is worth running versus a broader web_metadata_discovery or sensitive_file_exposure_scan.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower; the description still adds genuinely useful behavior beyond them by stating that only HEAD requests are issued and that file contents are never read, which tells the agent this is a low-impact, non-exfiltrating probe. It stops short of describing error handling, timeouts, or what a 'candidate' result 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?

A single sentence with no filler, and the most decision-relevant facts (method, scope, non-invasive nature) are front-loaded. Nothing needs trimming.

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

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

An output schema exists, so return values need not be explained, and annotations carry the safety profile. However, with 0% schema description coverage and a required url parameter that is never discussed, the definition leaves an agent guessing about input semantics for an otherwise simple two-parameter tool.

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

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

Schema description coverage is 0% and neither parameter (url, paths) is mentioned in the description. The phrase 'small curated set of high-risk paths' only loosely gestures at how the optional paths array behaves and says nothing about the required url, URL format, or the 20-item cap.

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 mechanism (HEAD requests), a specific target class (a small curated set of high-risk paths) and a specific output (candidates, not contents), so an agent knows exactly what the tool does. It does not explicitly name or contrast itself with the closest sibling, web_directory_scan, which 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?

There is no statement of when to reach for this tool versus web_directory_scan, http_probe, or robots_txt_analysis, and no exclusions or prerequisites. The 'small curated set' wording hints that this is a quick targeted check rather than a full brute force, but that inference is left entirely to the reader.

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, idempotentHint, non-destructive, and closed-world, so the safety profile is covered structurally. The description adds one genuinely useful behavioral note — that secrets are withheld — plus the hint that some dependencies are optional and may be absent. It says nothing about failure modes or what a degraded result 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?

A single front-loaded sentence with no filler. The security-relevant qualifier ('without exposing secrets') is placed where it will be read first.

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

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

An output schema exists, so return structure need not be described, and with zero parameters the schema burden is nil. The description covers scope and the secret-safety guarantee, leaving only the question of what 'health' comprises — minor given the output schema carries the field detail.

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

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

The tool takes no parameters, so there is no parameter semantics to document; baseline 4 applies. Schema coverage is 100% on an empty object, so nothing is missing.

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

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

States a specific verb ('Report') and a specific resource ('safe configuration and optional dependency status'), which is enough for an agent to know this surfaces the server's own health rather than scanning a target. It is distinguishable from the scan-oriented siblings by subject matter, though it never explicitly says whose server or why this differs from an assessment_summary.

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

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

There is no statement of when to call this versus alternatives such as assessment_summary, nor any precondition or trigger described. The agent must infer that this is a diagnostic/introspection call rather than a security test.

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 the full safety profile (readOnly, idempotent, openWorld, non-destructive). The description adds scoping context – same-origin only, 'bounded' inventory, and authorization classification – but is silent on rate limits, redirect handling, or what 'bounded' concretely means.

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

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

A single front-loaded sentence with the action verb first and no filler. Dense but readable; it earns its place, though 'bounded' is an unexplained term.

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

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

Output schema exists, so return values need not be described, and annotations carry the safety profile. The definition is adequate for a read-only analysis tool, but the unexplained 'bounded URLs' and total absence of parameter guidance leave real gaps.

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

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

Schema description coverage is 0% for 2 parameters, so the description must compensate, and it does not. Neither 'url' nor 'sitemap_path' (including its default '/sitemap.xml') is mentioned, leaving the agent to infer both from names alone.

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

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

States a specific verb (fetch) and resource (sitemap) plus concrete actions: inventory URLs and distinguish authorized from external entries. This meaningfully separates it from generic crawlers like web_crawler, though it doesn't explicitly name a sibling to contrast with.

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

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

No guidance on when to use this versus the many adjacent tools (web_crawler, robots_txt_analysis, gau_url_discovery). The 'same-origin sitemap' phrasing implies a scope but provides no context, prerequisites, or 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 the safety profile (readOnly, idempotent, non-destructive, openWorld). The description adds genuinely new behavioral context: the inspection is bounded and it deliberately does not return map contents, setting expectations about the output.

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

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

A single tight sentence, front-loaded with the action and finished with the key output caveat. No filler.

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

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

With an output schema present, return values need not be explained, and the description covers the non-obvious 'no map contents' behavior. The main residual gap is the missing guidance on the required url parameter's acceptable form.

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

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

Schema description coverage is 0%, so both parameters are undocumented structurally. The phrase 'bounded set' only faintly gestures at max_scripts, and nothing explains whether 'url' is a page URL, a script URL, or a domain, leaving the required parameter's expected form ambiguous.

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

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

The description names a specific verb ('Inspect'), resource ('authorized JavaScript files'), and target artifact ('sourceMappingURL references'), which clearly separates it from generic crawlers or javascript_endpoint_discovery. It stops short of naming an alternative sibling, so it falls short of the top tier.

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 word 'authorized' implies a scope-approval prerequisite, but the description never states when to reach for this tool versus javascript_endpoint_discovery or web_crawler, nor any explicit exclusion. Usage must be inferred.

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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered without description help. The description adds the scope of what is inspected (external scripts and stylesheets) but says nothing about whether the target page is fetched/crawled, whether the analysis is passive or active, or any rate/depth constraints — a real gap given openWorldHint implies network egress.

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

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

A single front-loaded sentence with no filler; the action and object are stated immediately. It is efficient, though its terseness leaves the ambiguities noted in other dimensions unaddressed.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. What remains missing is the meaning and expected form of the url parameter and the extent of scanning, which an agent needs in order to invoke this correctly.

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

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

One parameter (url) with 0% schema description coverage, so the description carries the full burden and fails to define it. It never clarifies whether the URL is a single page to inventory, a site root to crawl, or an arbitrary resource — a consequential ambiguity for a coverage tool.

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

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

States a specific pair of verbs (inventory, measure) applied to a specific resource class (external scripts/stylesheets) and a specific metric (Subresource Integrity coverage). An agent can distinguish this from csp_analysis or headers_analysis by the SRI framing, though the description never explicitly contrasts itself with those siblings.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives among the many sibling analysis tools. The agent must infer from the name alone that this is the SRI-specific check rather than a general header or CSP scan.

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

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

Annotations already declare readOnly, idempotent, open-world, and non-destructive, so the safety profile is covered by structured data. The description adds the specific aspects inspected (identity, validity, protocol, cipher, trust) but says nothing about permissions needed, rate limits, or failure behavior for unreachable hosts.

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

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

A single front-loaded sentence covering the verb and the inspected facets, with no filler. It is efficient, though the brevity contributes to the coverage gaps noted elsewhere.

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

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

An output schema exists, so return values need not be described, and annotations cover the safety profile. Combined with the explicit list of inspected aspects, this is nearly complete for a 2-parameter read tool; the missing port semantics and sibling differentiation are the only real gaps.

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

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

Schema description coverage is 0%, so the schema names 'target' and 'port' with constraints and a default of 443 but never explains them. The description only implicitly references 'host' and never mentions the port parameter or its default, leaving the parameter semantics essentially undocumented across both sources.

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 pairs a specific verb ('Inspect') with a concrete resource list ('certificate identity, validity, protocol, cipher, and trust'), which is far more informative than the bare name ssl_scan. It does not, however, distinguish itself from the sibling tls_configuration_analysis, which an agent could easily confuse with it.

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

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

The phrase 'for an authorized host' hints at a prerequisite (target authorization), giving some implied usage context. But there is no explicit when-to-use guidance and no direction on choosing this over tls_configuration_analysis, port_scan, or http_probe, so an agent must infer the routing decision.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false, openWorldHint), so the description only needs to add operating context. It does add two useful facts: the primary source is passive CT logs, and an optional active DNS resolution step exists. It stops short of explaining what the active mode costs, what it returns, or any rate/timeout constraints on live resolution.

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

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

A single front-loaded sentence with no filler; the passive-then-optional-active structure is easy to parse. It is arguably over-terse for a tool with an entirely undocumented schema, but nothing is wasted.

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

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

An output schema exists, so return values need no explanation, and rich annotations cover safety semantics. The remaining gaps are sibling differentiation and candidate/active mechanics, which push this below a definitively complete definition but leave it serviceable for a 3-parameter discovery tool.

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

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

Schema description coverage is 0%, so the description must carry the semantics, and it only partially maps to the three parameters: 'certificate-transparency logs' ties to domain, 'optionally resolve' ties to active, and 'bounded candidate list' gestures at candidates. It never explains that candidates are DNS names to resolve, what the bound actually is (schema enforces maxItems 100), or the default of active=false, leaving important details to the schema's raw constraints.

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 'query certificate-transparency logs' plus the resource (subdomains/candidate list) makes the mechanism clear, and 'optionally resolve' hints at the active mode. However, with siblings like subfinder_discovery, amass_passive_discovery, assetfinder_discovery and dns_enumeration, the description never says how this differs from those overlapping subdomain-discovery tools.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites (e.g. a domain that participates in CT), and no routing to any of the four sibling subdomain-discovery tools that an agent must choose between. The only implied usage is 'you want subdomains', which the siblings also satisfy.

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, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds two useful traits beyond that: the binary must be 'explicitly enabled' (an environment/config precondition) and results are filtered to 'in-scope subdomains' (a post-processing behavior). It does not mention rate limits, source coverage, or timeout behavior, so 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?

A single front-loaded sentence that names the action, the tool, and the scope with no filler. It is efficient, though the trailing scope-filter clause is doing double duty that could be unpacked without bloat.

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

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

An output schema exists, so return values needn't be described, and annotations cover safety. However, for a crowded discovery toolset the description omits any guidance on when this run is preferred over the many sibling subdomain/DNS enumeration tools, leaving a real gap for correct tool selection.

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

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

Schema coverage is 0% and there is one required parameter, so the description carries the burden. 'One authorized domain' hints that the value is a single in-scope domain rather than a list, but it gives no format, normalization, or edge-case detail (subdomain vs apex, wildcard handling) beyond what the bare schema string type implies.

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

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

States a specific verb ('Run') plus the resource (the Subfinder binary) and scopes it to one domain, so an agent knows this is a targeted passive-subdomain discovery run. It names Subfinder specifically, which gives mild differentiation from the generic 'subdomain_enumeration' sibling, but it never contrasts itself against near-identical tools like amass_passive_discovery or assetfinder_discovery.

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

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

There is a constraint ('one authorized domain') but no explicit when-to-use or when-not-to-use guidance. In a sibling set containing subdomain_enumeration, amass_passive_discovery, assetfinder_discovery, and dns_enumeration, an agent is left to guess which discovery tool is appropriate; the description offers no routing 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 declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds only the vague phrase 'using bounded response evidence', which hints at limited probing depth but doesn't specify scope, depth, or any auth/rate considerations.

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

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

A single tight sentence with the action front-loaded and no filler. Nothing can be trimmed without losing the enumerated target categories.

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

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

An output schema exists, so return-value explanation is unnecessary, and the annotations carry the safety profile. However, for a tool with zero usage guidance and an undocumented sole parameter, the definition is minimally viable rather than complete.

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

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

There is a single required 'url' parameter with 0% schema description coverage, so the schema contributes no semantic hints. The description implies remote fetching of a response ('bounded response evidence') but never names the parameter or its expected format, leaving a small but real gap on the only input.

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

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

States a specific verb ('Fingerprint') plus the resource categories it targets (frameworks, platforms, servers, generators), so the agent knows exactly what output class to expect. It does not explicitly differentiate itself from near-neighbors like favicon_fingerprint or headers_analysis, so it stops short of a 5.

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

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

The description gives no when-to-use condition, prerequisites, or alternative. With many overlapping fingerprint-style siblings (favicon_fingerprint, headers_analysis, http_probe), an explicit routing cue would be valuable and is absent.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and open-world behavior, so the safety profile is covered. The description adds that it probes an explicit protocol range (1.0-1.3) and flags obsolete protocols, plus the scope-pinning constraint, but says nothing about timing, rate limits, or side effects beyond what annotations imply.

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

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

A single efficiently worded sentence with the protocol range and goal front-loaded and no filler. It is terse to the point of under-specification, but nothing is wasted.

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

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

An output schema exists, so return-value explanation is not required, and annotations carry the safety profile. Still, for a tool with 0% parameter documentation and an obvious sibling overlap, the description leaves meaningful gaps in how to invoke it and when to prefer it.

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

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

Schema description coverage is 0% and neither 'target' nor 'port' is explained in the description. The phrase 'scope-pinned addresses' loosely maps to the target parameter but gives no format, syntax, or default guidance, and 'port' (default 443) is entirely unaddressed, so the description does not compensate for the schema gap.

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