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

With no annotations provided, the description carries the full burden. It discloses that the tool is passive ('without transmitting any packets'), requires monitor mode and root/sudo, captures wireless frames, and must only be used with authorization. It also mentions underlying tool (airodump-ng). It doesn't describe exact error behavior if prerequisites are missing, but covers key behavioral aspects.

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

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

The description is well-structured with clear sections (intro, Args, Returns, WARNING) and is front-loaded with the core purpose. It is not overly long, but the WARNING section repeats the legal authorization point, which is slightly redundant. Still, every line serves a purpose.

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

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

For a tool with no annotations and moderate complexity, the description covers purpose, usage prerequisites, parameters, return values, and legal/ethical warnings. It lacks mention of what happens if the interface is not in monitor mode (error handling), but the core operational context is well-covered.

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

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

The input schema has 0% coverage, but the description compensates by explaining each argument: interface ('Wireless interface in monitor mode e.g. wlan0mon'), scan_time ('Duration in seconds to capture'), and timeout ('Override default timeout'). The timeout description is somewhat generic, but overall it adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Passively scan for wireless networks using airodump-ng... without transmitting any packets.' This specific verb+resource combination (passively scan + wireless networks) distinguishes it from sibling tools like nmap_scan and masscan_scan, which target wired/network scanning.

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

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

It provides clear context on when to use the tool: 'monitor mode required' and 'passively capture wireless network information.' It also lists prerequisites (root/sudo, monitor mode) and legal authorization. However, it does not explicitly name alternatives or state 'use this for wireless, not for wired,' so it stops short of full when-not 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?

With no annotations provided, the description carries the full burden. It discloses important behavioral traits: active mode 'sends DNS queries directly to target's nameservers' and the allowed_hosts requirement. This adds meaningful context beyond a generic enumeration tool, though it could mention more (e.g., rate limits, resource usage).

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

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

The description is well-structured with Args, Returns, and Note sections. Every sentence earns its place, and the front-loaded purpose sentence immediately conveys what the tool does. It is succinct without sacrificing essential details.

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

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

The description covers the tool's purpose, parameters, return values, mode differences, and a critical prerequisite. Given the tool's complexity (3 parameters, no annotations, output schema present), this is a complete and self-sufficient description.

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 explain all parameters. It does so thoroughly: domain with example, mode with definitions, timeout with units and default behavior. This fully compensates for the schema's lack of 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?

The description clearly states the tool's purpose: 'Enumerate subdomains and map attack surface using Amass.' It identifies the specific resource (subdomains) and implies a broader scope (attack surface). However, it does not explicitly differentiate from sibling tools like subfinder_enum or dns_enumerate, so it falls short of a 5.

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

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

The description provides clear context on when to use each mode: passive (no direct interaction) vs active (DNS brute-force + zone walk). It also notes a prerequisite (allowed_hosts). However, it lacks explicit alternatives or when-not-to-use guidance, which would be a 5.

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

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

With no annotations, the description carries the full burden. It discloses key behavioral traits: uses httpx directly, pure Python, performs a single GET request, and returns scores/grades/recommendations. This is more transparent than many tools, though it doesn't explicitly state it is read-only or non-destructive. The single GET detail effectively communicates the operational behavior.

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

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

The description is well-structured: a clear one-line purpose, a brief elaboration, then sections for Args, Returns, and Note. Every sentence adds value, and it is concise without being too short. The organization makes it easy to scan.

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

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

The description covers the tool's purpose, how it works, parameters, and return value. Given that an output schema exists and the tool is a simple read-only analyzer, the description is sufficiently complete for an agent to use it correctly. No critical information is missing.

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

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

Schema description coverage is 0%, and the description compensates by explaining each parameter in the Args section: url, follow_redirects, and timeout_seconds. It adds meaning beyond the bare schema types/defaults, clarifying that follow_redirects affects destination and timeout_seconds controls request duration.

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

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

The description clearly states the tool's purpose: 'Analyze HTTP security headers for a web application.' It further specifies it checks for critical security headers and flags information disclosure headers, which is specific and distinguishes it from sibling tools like ssl_tls_check (SSL/TLS) or whatweb_scan (technology detection).

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 through its stated functionality (e.g., 'Checks for the presence and correctness of critical security headers'), but it does not explicitly state when to use this tool versus alternatives or when not to use it. Sibling tools include many scanners, but no direct alternative for header analysis; still, no explicit usage guidance is provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It notes that Arjun sends many requests and that JSON/XML modes test parameters in the request body, giving useful insight into runtime behavior. It does not cover potential auth or side effects, but the core behavior is transparent.

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

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

The description is well-structured with Args, Returns, and Note sections. Every sentence adds value; no redundancy or fluff. The main purpose is front-loaded, and the notes are concise but informative.

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

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

Given the presence of an output schema and 4 relatively simple parameters, the description fully covers prerequisites, behavior, and parameter semantics. It even includes return value information despite the output schema existing, making it self-contained.

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 explain all parameters. It does: url, method with options, optional wordlist, and timeout override. This adds meaning beyond raw types, though it omits default timeout details and wordlist format specifics.

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

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

The description opens with a specific verb and resource: 'Discover hidden HTTP parameters in web endpoints using Arjun.' This clearly distinguishes it from sibling tools like ffuf_fuzz or gobuster_scan, which focus on fuzzing or directory enumeration.

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

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

The description provides clear usage context: target must be in allowed_hosts, and it warns about rate-limited endpoints. It does not explicitly name alternative tools or state when not to use it, but the context is sufficient for selection.

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

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

With no annotations provided, the description fully carries the burden of behavioral disclosure. It warns that BloodHound collection is detectable by EDR/SIEM, generates significant LDAP traffic, requires valid credentials, and has an allowed-hosts constraint. It also notes that passwords are redacted in logs and that output is written as JSON/ZIP files, providing rich behavioral context beyond 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?

The description is well-structured and appropriately sized. It front-loads the purpose, then uses an Args list, Returns summary, and WARNING section. Every sentence adds value—no filler or repetition—and the format is scannable for an AI agent.

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

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

For a tool with 8 parameters, no annotations, and an output schema not shown, the description covers prerequisites, behavior, output, and safety warnings. It explains what the tool returns (collection summary with file locations and AD object counts) and flags operational risks, making it sufficiently complete for correct invocation and expectation setting.

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

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

The input schema has 0% description coverage, but the description compensates by documenting all 8 parameters with meaningful semantics: target is a Domain Controller IP, hashes use LM:NT format, collection_method lists valid values, output_dir writes JSON/ZIP files, and timeout overrides the scan timeout. This fully bridges the schema's lack of 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?

The description opens with a specific verb and resource: 'Collect Active Directory data for BloodHound attack path analysis.' It further details what bloodhound-python enumerates (users, groups, computers, GPOs, trust relationships), making the tool's purpose unmistakable and distinguishing it from AD enumeration siblings like impacket_secretsdump or enum4linux_scan.

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

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

The description provides clear context for when this tool is appropriate: it maps attack paths to Domain Admin and requires valid domain credentials. It also includes operational prerequisites such as the target being in tengu.toml allowed_hosts. However, it does not explicitly name alternatives or state when not to use this tool, so it misses the top tier for usage 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?

No annotations are provided, so the description must carry the full burden. It discloses that the tool crawls the site, generates network traffic, and respects the allowed_hosts constraint. It also notes depth-related traffic concerns. However, it does not cover error handling, robots.txt behavior, or potential side effects beyond creating the output file, leaving some behavioral traits undisclosed.

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

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

The description is well-structured with a clear one-sentence summary, followed by compact Args, Returns, and Notes sections. Every sentence adds relevant information without redundancy. It is concise yet comprehensive.

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

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

Given the tool's complexity (6 params, no annotations, output schema present), the description covers purpose, all parameters, return values, usage constraints, and a caution about traffic. It is nearly complete, though it could mention prerequisites like authentication but the allowed_hosts note covers access control. Overall it provides sufficient context for an agent 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?

The input schema provides no descriptions for parameters, so the description's Args section fully compensates by explaining each parameter's meaning and defaults. It adds value like depth max 5 and default word length, going beyond the raw schema. This effectively documents all 6 parameters.

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

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

The description opens with a specific verb+resource: 'Generate a custom wordlist by crawling a website with CeWL.' It clearly states the tool's function and distinguishes it from sibling crawling or scanning tools by focusing on wordlist generation for password attacks. The 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?

The description implies usage for creating organization-specific wordlists for password attacks and provides clear context through notes about cautious depth and allowed_hosts requirements. However, it does not explicitly name alternative tools or state when not to use this tool, so it lacks explicit exclusion 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?

No annotations are provided, so the description carries the full burden. It discloses output fields but does not mention safety behavior, side effects, or external network calls. This leaves the agent uncertain whether the tool makes outbound requests or is strictly local.

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

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

Two sentences, clear structure, and no redundant text. The output description adds useful details 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?

For a zero-parameter tool with an output schema, the description explains the check scope and return values. It could mention prerequisites or usage context, but for this simple tool it is largely 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 are zero parameters, so the description inherently cannot add parameter meanings. The baseline of 4 applies due to no parameters.

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

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

The description uses a specific verb 'Check' and identifies the resource 'current anonymity level', specifying IP exposure, DNS leaks, and proxy headers. It clearly distinguishes from sibling tools like proxy_check and tor_check by focusing on the overall anonymity assessment.

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 use this tool versus alternatives, such as proxy_check or tor_check. The description implies its usage but does not state scenarios, exclusions, or conditions.

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

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

With no annotations, the description takes responsibility for behavioral disclosure. It states it scans local files only, requires no network access, and needs no allowlist check, signaling a safe, non-exfiltrating read operation. It also describes the return grouping, adding useful behavioral context.

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

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

The description is well-structured with sections for Args, Returns, and Note, each adding essential information without redundancy. It is concise and front-loaded with the primary purpose, making it easy to parse quickly.

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

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

Given the tool's complexity and the existence of an output schema, the description covers purpose, parameters, return values, and operational caveats like local-only scanning and no allowlist need. Minor omissions such as recursion behavior do not detract significantly from its usefulness.

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 0% description coverage, but the description fully compensates by explaining each parameter, including allowed framework values and example check IDs. This provides the semantic context the structured schema lacks, leaving no ambiguity about the arguments.

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

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

The description clearly states the tool scans Infrastructure as Code for security misconfigurations using Checkov, which distinguishes it from sibling scanners focused on other targets. It lists supported frameworks, providing a precise scope and making the tool's use case immediately obvious.

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

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

It provides clear context by enumerating supported IaC frameworks, implying this is the right tool for IaC security scans. However, it does not explicitly name alternative scanners or state when not to use it, so guidance is contextual but not comparative.

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

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

With no annotations provided, the description carries the burden. It explains the return value (catalog with installation status, paths, versions) and implies a read-only, non-destructive behavior. No additional side effects or prerequisites need disclosure for a tool of this simplicity.

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

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

The description is two sentences: the first states the primary purpose, the second adds return details and usage context. It is concise, front-loaded, and contains no fluff.

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 zero-parameter, read-only tool with an output schema, the description fully covers what the tool does, what it returns, and when to use it. No additional context is needed.

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

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

The input schema has zero parameters, so the baseline is 4. No parameter descriptions are needed, and the schema coverage is trivially 100%.

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

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

The description clearly states the tool checks which external pentesting tools are installed and available, with a specific verb ('check') and resource. It distinguishes itself from sibling scanning tools by focusing on tool availability rather than performing scans.

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

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

The description provides clear context by stating it is useful for diagnosing missing dependencies before starting a pentest engagement, but does not explicitly mention when not to use it or alternatives.

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

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

With no annotations provided, the description carries the full burden and discloses key behavioral traits: it requires explicit authorization, the target must be in tengu.toml allowed_hosts, and it returns test results with evidence. It could go further by explicitly stating that it sends crafted payloads to the target, but the purpose makes this clear.

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

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

The description is well-structured with headers, front-loads the purpose and a critical warning, and uses concise bullet-like sections. Every sentence adds value, and the moderate length is appropriate for a tool with five parameters and safety requirements.

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

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

The description covers the tool's purpose, all parameters, return value, and prerequisites, making it complete for an agent to invoke correctly. The presence of an output schema means the return value description is a bonus, not a necessity.

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

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

The input schema has 0% description coverage, but the description thoroughly explains every parameter (url, method, data, level, timeout) with defaults, examples, and the critical naming constraint. This fully compensates for the schema's lack of 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?

The description explicitly states 'Test a URL for OS command injection vulnerabilities using Commix,' clearly defining the tool's function and resource. It distinguishes itself from sibling scanning tools like sqlmap_scan (SQL injection) and xss_scan (XSS) by naming the vulnerability class.

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 clearly indicates when to use the tool (for OS command injection testing) and provides important operational prerequisites like explicit authorization and allowed_hosts. It does not explicitly compare to alternatives or state when not to use it, but the purpose strongly implies the appropriate context.

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

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

With no annotations, the description must carry the full burden. It specifies the output (attack chains, risk score, remediation recommendations) and mentions required input fields, but does not disclose potential side effects (e.g., whether it makes network calls) or limitations (e.g., what happens if findings are malformed). This is acceptable but 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?

The description is well-structured and front-loaded with the purpose in the first sentence. The Args and Returns sections are concise and informative, with no superfluous content. Every line adds value for the agent.

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

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

Given the tool's complexity and the presence of an output schema (though not shown), the description covers the essential aspects: input format, processing logic, and output. It lacks details on edge cases or handling of partial data, but remains sufficient for an agent to understand the tool's role and invoke it correctly.

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

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

The input schema is minimal, containing only an array of arbitrary objects. The description compensates by specifying that the array contains Finding objects and enumerating expected fields (severity, owasp_category, cve_ids, tool). This adds significant meaning beyond the schema, guiding correct invocation.

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

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

The description clearly states a specific verb and resource: 'Correlate multiple findings to identify attack chains and compound risks.' This distinguishes it from sibling tools, which primarily perform individual scans or checks. The opening sentence makes the tool's purpose unambiguous.

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

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

The description explains that the tool analyzes findings from multiple tools to identify patterns and compound risks, implying it should be used after collecting findings from various scanners. It does not explicitly name alternatives or state when not to use it, but the context is clear enough for an agent to determine suitability.

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

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

With no annotations provided, the description carries the transparency burden. It explains the nature of the scan, the impact of CRLF injection, and the allowed_hosts constraint. It does not explicitly state whether the scan is read-only or mention rate limits, but the provided context (threads, timeout) and return behavior give reasonable insight into the tool's operations.

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

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

The description is well-organized with clear sections (Description, Impact, Args, Returns, Note). Each sentence adds meaningful information, and the length is appropriate for the complexity of the tool with three parameters and a security-relevant context.

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

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

The description covers purpose, parameters, return values, and a usage constraint. It is sufficient for an agent to select and invoke the tool appropriately, especially given the presence of an output schema. The note about allowed_hosts is a critical context piece that is not in 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?

Despite the input schema having no property descriptions, the description compensates fully with an Args section. It explains each parameter's purpose: url with an example, threads with default and max, and timeout as an override. This is exemplary parameter documentation that goes far beyond the schema.

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

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

The description clearly states the tool's function: "Scan a URL for CRLF injection vulnerabilities using CRLFuzz." This specifies the exact vulnerability type, the target resource, and the underlying tool, making it easily distinguishable from sibling scanning tools like xss_scan or nuclei_scan.

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 clearly implies when to use the tool (to test for CRLF injection) and includes an important prerequisite: "Target must be in tengu.toml [targets].allowed_hosts." However, it does not explicitly contrast with alternative tools or provide when-not-to-use guidance, so it lacks the full differentiation expected for a 5.

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

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

With no annotations, the description carries the full burden of transparency. It discloses the data sources (NVD and CVE.org) and enumerates the returned fields (CVSS scores, CWE mappings, affected products, references, exploit cross-references). It does not cover potential rate limits or error behavior, but for a read-only CVE lookup this is reasonable. No contradictions with annotations exist (none provided).

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

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

The description is well-organized with a summary, Returns list, and Args/Returns sections. It is front-loaded with the primary purpose. However, there is slight redundancy: the first paragraph lists return items that are partially repeated in the Returns section. Still, every sentence earns its place and the length is appropriate.

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

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

For a simple one-parameter tool with an output schema, the description is complete. It explains the input format, the data sources, and the expected return content. There is no ambiguity about what the tool does or how to invoke it. The existing output schema covers return structure, so the description doesn't need to over-explain.

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 provides only a type 'string' for cve_id with 0% description coverage. The description compensates thoroughly by explaining the required format 'CVE-YYYY-NNNNN' and providing a concrete example ('CVE-2024-1234'). This adds essential meaning beyond the bare schema.

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

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

The description clearly states the tool 'Fetch complete details for a specific CVE' from NVD and CVE.org, using a specific verb ('Fetch') and resource ('specific CVE'). This distinctly differentiates it from the sibling tool 'cve_search', which implies searching rather than fetching a known, single CVE.

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 explicitly says 'for a specific CVE', indicating the tool is intended for when a known CVE ID is available. It does not explicitly name alternatives or exclusions, but the word 'specific' provides clear context against the sibling search tool. The guidance is clear enough for an agent to decide when to invoke it.

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

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

With no annotations, the description discloses several behavioral traits: it queries the NVD database, caches results locally for 24 hours to respect API rate limits, and warns that the parameter must be named 'keyword' not 'query'. These go beyond a generic search description.

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

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

The description is somewhat lengthy but well-structured with an important note up front and a clear Args/Returns format. Most sentences add necessary detail, though the keyword parameter is mentioned twice redundantly.

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

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

Given an output schema exists, the description adequately covers parameter semantics, defaults (implicit via schema), and behavior. It does not clarify whether parameters can be combined or if no parameters returns all CVEs, but it is fairly complete for a search 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?

The input schema has 0% description coverage, so the description must compensate. It explains every parameter with examples, constraints (e.g., max_results max 100, severity values), and meaning for cpe_name, days_back, etc., adding significant value beyond the schema.

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

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

The description clearly states the tool searches CVEs by keyword, product, CPE, or severity, with specific verbs and resource. However, it does not explicitly distinguish itself from the sibling 'cve_lookup' tool, so it lacks 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 gives context (queries NVD, results cached) but does not say when to use this tool versus alternatives like 'cve_lookup' or 'searchsploit_query'. There is no explicit when-to-use or alternative 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?

Since no annotations are provided, the description carries full responsibility for behavioral disclosure. It explicitly discloses that no external process is spawned and that it uses dnspython as a pure-Python client. It also describes the return format: 'DNS records grouped by type with values and TTLs.' While it does not mention error handling or potential network usage, these are inherent to a DNS lookup tool and the key behavioral traits are covered.

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

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

The description is well-structured with a one-line summary, a behavioral note, and clearly labeled Args and Returns sections. It is appropriately sized, with every sentence contributing useful information and no fluff. The formatting with headers and bullet-like entries enhances readability.

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

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

For a tool with three parameters and no annotations, the description provides all necessary invocation details: parameter semantics, defaults, return format, and implementation notes. It even mentions the pure-Python nature to set expectations. The output schema (not shown) likely handles precise return typing, so the description is sufficient for an agent to correctly select and use the tool.

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

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

The input schema has no parameter descriptions (0% coverage), so the description fully compensates. It explains each parameter with examples and defaults: 'domain: Target domain to query (e.g. "example.com")', 'record_types: List of DNS record types to query. Defaults to all common types...', and 'nameserver: Optional custom DNS resolver IP (e.g. "8.8.8.8"). Defaults to system resolver.' This adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool's function: 'Query DNS records for a domain.' It specifies the resource (DNS records), the action (query), and enumerates supported record types. It also distinguishes itself from siblings by emphasizing 'No external process is spawned — this is a pure-Python DNS client,' which separates it from tools like dnsrecon_scan that may rely on external binaries.

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

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

The description provides clear context for when to use the tool: it supports custom record types, defaults to common types, and offers an optional nameserver. It implies lightweight usage by noting the pure-Python implementation, but it does not explicitly name alternatives or state when not to use it, such as 'for comprehensive DNS recon, use dnsrecon_scan.' Thus it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers the expected output (DNS records, zone transfer results, raw output), a failure mode (axfr may fail), and a prerequisite (allowed_hosts). It does not disclose timing or rate-limit behavior, but for a read-only recon tool this is solid coverage.

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

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

The description is well-structured with clear sections (capabilities, Args, Returns, Note) and is appropriately sized. Each section earns its place, and the purpose is front-loaded in the first sentence.

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

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

Despite having no annotations, the description provides complete operational guidance: it names the underlying tool, lists all supported scan modes, documents every parameter, and includes prerequisites plus failure caveats. With an output schema present to handle detailed return structure, nothing essential is missing.

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

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

Schema description coverage is 0%, yet the description's Args section fully compensates by explaining all three parameters. Most valuably, it enumerates every scan_type value (std, brt, axfr, rvl, goo) with a short explanation, which the schema itself lacks entirely.

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

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

The description opens with 'Perform DNS reconnaissance using DNSRecon' and enumerates supported capabilities (zone transfers, brute-force, PTR lookups, standard record enumeration). It is specific about the tool and scope but does not explicitly differentiate from sibling DNS tools like subfinder_enum or dns_enumerate.

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

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

The description provides clear operational context: the target must be in tengu.toml [targets].allowed_hosts, and zone transfer (axfr) may fail if nameservers are properly configured. However, it never states when to prefer this tool over sibling DNS enumeration tools or what alternatives exist, so it lacks explicit when/when-not 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?

With no annotations, the description carries the burden and discloses the passive nature ('only sends DNS queries, no HTTP requests') and the permutation logic. It also explains registered_only and check_mx semantics, but omits potential rate limits or error behavior.

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

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

The description is well-organized with distinct sections for purpose, args, returns, and notes. Every sentence provides useful information; the Args list is necessary because the schema lacks descriptions, and there is no repetition or fluff.

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

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

Given the tool's complexity, the description covers purpose, all parameters, return values, and key constraints like allowed_hosts and passive operation. With an output schema present, this is sufficient for an agent to decide on and invoke the tool correctly.

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

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

The description explicitly explains all five parameters with meanings and defaults, fully compensating for the 0% schema description coverage. The domain example and registered_only/default values add meaning beyond the raw schema.

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

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

The description clearly states the tool detects typosquatting and phishing domains by generating permutations and checking registration with dnstwist. This specific verb+resource+method distinguishes it from sibling DNS tools like dns_enumerate or whois_lookup.

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

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

The description implies usage for typosquatting investigation and includes prerequisites (allowed_hosts) and behavioral context (passive OSINT). However, it does not explicitly mention alternatives or state when not to use this tool, stopping short of full 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?

With no annotations, the description carries the full burden. It discloses that passwords are redacted in logs and that the target must be pre-approved, which is useful. However, it does not mention that the tool actively connects to the target, potential noise or side effects, or how timeouts are handled, which are important for an active enumeration tool.

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

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

The description is well-structured with clear sections (Args, Returns, Note), front-loaded with the primary purpose, and every sentence serves a purpose. It is concise and scannable.

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

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

Given that an output schema exists, the description appropriately summarizes return values rather than detailing them. It covers prerequisites, redaction behavior, and parameter purposes. It lacks comparison to alternatives and more on timeout semantics, but for a moderate-complexity scan tool, it is sufficiently complete.

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

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

Schema description coverage is 0%, and the description compensates by explaining each parameter: target (IP/hostname on SMB ports), username (optional for authenticated enumeration), password (redacted), and timeout (override default). This adds meaningful context beyond the schema's raw type definitions, though it could provide more details on format 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 description clearly states the tool's function: 'Enumerate SMB/NetBIOS information using enum4linux-ng' and lists returned data (users, groups, shares, password policy). It uses a specific verb and resource, and the tool name itself differentiates it, but it doesn't explicitly contrast with sibling SMB tools like smbmap_scan or nxc_enum.

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

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

The description provides prerequisites (requires SMB access on port 139/445, target must be in allowed_hosts) but does not offer explicit when-to-use vs alternatives or when-not-to-use. Usage is implied for SMB enumeration, but no selection guidance is provided relative to similar 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?

With no annotations, the description must carry the burden of behavioral disclosure. It does so by revealing that Feroxbuster recurses by default, requires the target to be in allowed_hosts, and returns status codes, content lengths, and word counts. However, it omits potential side effects like network noise or rate limiting, so it is strong but not exhaustive.

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

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

The description is well-structured with clear sections (Args, Returns, Note) and front-loads the critical parameter-naming pitfall. Every sentence adds value—the comparison to Gobuster/FFuf, default recursion behavior, and allowed_hosts note are all necessary. The repeated 'target' reminder is justified given the common mistake.

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

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

Despite having no annotations and no schema descriptions, the tool description covers purpose, parameters, return format, and a key prerequisite (allowed_hosts). It leverages the output schema to avoid re-explaning return fields. It falls short of a 5 by not addressing potential error conditions or edge cases like invalid wordlists, which would fully round out the context for an autonomous 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%, but the description fully compensates by explaining every parameter with usage details, defaults, and constraints. For example, it notes the target parameter must be named 'target' not 'url', includes an example, and specifies max values for threads and depth. This is exemplary enrichment beyond the raw schema.

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

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

The opening sentence explicitly states 'Perform recursive content discovery using Feroxbuster,' giving a specific verb and resource. It also distinguishes from siblings by noting 'Unlike Gobuster or FFuf, Feroxbuster recursively discovers directories,' which clarifies its unique scope among similar tools.

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

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

The description provides an explicit comparison with Gobuster and FFuf, indicating when Feroxbuster's recursive behavior is advantageous. It also gives practical deployment context with the allowed_hosts prerequisite and depth control guidance, but does not fully state when to avoid this tool (e.g., for single-path fuzzing).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the required FUZZ placeholder and automatic appending, how filter/match codes work, and default thread/rate behavior. It does not mention potential side effects like high request volume or authorization requirements, but it provides substantial operational detail.

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

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

The description is well-structured with a clear opening summary, an Args section that explains each parameter, and a Returns section. It uses bullet-like formatting and front-loads the core purpose. Every sentence adds value and nothing is redundant.

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

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

Given the tool's complexity (10 parameters, no schema descriptions, no annotations), the description is thorough. It covers the FUZZ substitution rule, parameter semantics, defaults, and return values, making the tool fully understandable without needing to inspect the schema or output format.

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 provides zero description coverage, but the description compensates fully by listing and explaining every parameter in the Args section, including url, wordlist, method, filter_codes, match_codes, extensions, threads, rate, headers, and timeout. This far exceeds the schema's bare structure.

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

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

The description clearly states 'Fuzz directories, files, and endpoints using FFUF' with a specific verb and resource. It distinguishes itself by naming FFUF, but does not explicitly contrast with similar sibling tools like gobuster_scan or feroxbuster_scan, so it lacks direct 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 provides clear context for when to use the tool: 'discover hidden files, directories, APIs, and endpoints that are not linked from the application's public pages.' It does not explicitly mention alternatives or when not to use it, but the use case is unambiguous.

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

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

With no annotations, the description carries the transparency burden. It discloses output behavior: formats (PTES/OWASP), output types (full/executive/etc.), and the output_path behavior returning content inline if empty. It does not mention overwrite behavior or external dependencies, but is reasonably transparent for a reporting tool.

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

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

The description is well-structured with a clear one-line purpose, an Args list, and a Returns section. It is slightly verbose with phrases like 'professional' and 'comprehensive' adding little, but the layout is scannable and information-dense 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?

The description covers all parameters, return value, and report variants. With an output schema present, the return metadata is likely further specified. It lacks explicit prerequisites or side-effect warnings, but given the tool's complexity and completeness of input documentation, it is sufficiently contextual.

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

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

The input schema has 0% description coverage, but the description's Args section provides explanations for all 12 parameters, including valid report_type and output_format values. This fully compensates for the schema's lack of descriptions and adds meaning beyond the property 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?

The description clearly states it generates a professional penetration test report, with a specific verb ('generate') and resource ('penetration test report'). It distinguishes itself from sibling scanner and enumeration tools by focusing on report creation rather than data collection.

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 after findings are collected, noting that 'findings' should be a list of finding dicts from Tengu tools. However, it does not explicitly state when not to use it or compare it to alternatives, though no sibling tool competes directly.

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

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

With no annotations provided, the description carries the full burden. It discloses important behavioral constraints such as target path restrictions ('must be under an allowed directory'), the three scan modes, output formats, and the return structure including 'partially-redacted secret'. It does not mention potential side effects or performance implications, but for a read-only scanner this is adequate.

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

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

The description is concise and well-structured with clear sections (Args, Returns, Note). Every sentence adds useful information, and the total length is appropriate 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?

Given the tool's moderate complexity, no annotations, and a schema with no descriptions, the description covers all essential aspects: parameters, return format, usage notes, and constraints. It is sufficient for an agent to select and invoke the tool correctly.

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

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

The schema has no property descriptions (coverage 0%), but the description compensates fully by explaining each parameter: target (path), scan_type with possible values and meanings, report_format with example formats, and timeout as an override. This adds substantial semantic value beyond the bare schema.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Scan a repository or directory for secrets and credentials using Gitleaks.' This distinguishes it from sibling scanners like trufflehog_scan by naming the underlying engine, making the purpose unambiguous.

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

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

The Note section provides clear context for when to use each scan_type (e.g., 'Use detect for comprehensive historical scans', 'Use protect as a pre-commit hook'), which guides parameter selection. However, it does not explicitly compare against alternative secret-scanning tools or state when not to use this tool, so alternatives are not addressed.

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

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

With no annotations, the description carries full behavioral burden. It discloses rate limiting and the allowed_hosts requirement, which is useful, but does not mention network noise, external dependencies, or failure behavior. This is partial transparency.

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

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

The description is well-structured with an intro, Args list, Returns section, and Notes. It is not overly verbose, though it repeats some defaults already present in the schema. All sections are useful and 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?

Given the tool's complexity and output schema, the description covers usage, parameters, return type, and key constraints. It lacks discussion of alternative tools and some edge cases, but is fairly complete for a scanning 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 compensates by explaining all 7 parameters with one-line definitions and examples (e.g., extensions, status_codes defaults). This adds meaning beyond the schema, though some nuances like extension format are only hinted.

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 first sentence 'Brute-force directories, files, and virtual hosts using Gobuster' is a clear verb+resource statement. It covers the main use cases but does not explicitly distinguish from sibling tools like feroxbuster_scan or ffuf_fuzz, though the mode parameter adds DNS subdomains.

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

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

The description provides no guidance on when to use this tool versus alternatives like feroxbuster_scan or ffuf_fuzz. It only lists constraints (allowed_hosts, rate limiting) and mode descriptions, which are more prerequisites than usage direction.

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

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

With no annotations, the description carries the full burden and does a good job by disclosing external dependencies ('Requires Chrome/Chromium'), saving behavior ('Screenshots are saved locally to output_dir'), and the allowed_hosts constraint. It does not discuss rate limits or potential side effects, but the core behavioral traits are covered.

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

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

The description is well-organized with clear sections (Args, Returns, Note) and front-loads the primary purpose in the first sentence. Each sentence adds value, such as the return summary and the Chrome/Chromium requirement, without excessive fluff.

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

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

For a tool with 4 parameters and a moderate complexity, the description covers parameters, return values, prerequisites, and operational constraints. Even though an output schema exists, it still summarizes the return format, and the notes provide essential environmental context, making it fully self-sufficient.

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

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

The input schema provides no descriptions (0% coverage), so the description's Args section is the sole source of parameter meaning. It explains 'target' as URL, file, or CIDR based on mode; defines 'mode' options; clarifies 'output_dir' default; and notes 'timeout' as an override. This fully compensates for the lack of schema 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?

The description clearly states the tool 'Capture web screenshots for visual documentation using Gowitness', specifying both the action and the resource. It also mentions specific use cases (documenting web interfaces, login pages, web-based findings), distinguishing it from other scanning tools.

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

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

The description provides clear context for when to use it ('Useful for documenting web interfaces, login pages, and web-based findings in penetration test reports') and includes a prerequisite note about allowed_hosts. However, it does not explicitly name alternatives or state when not to use it, so it falls short of full 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?

Without annotations, the description carries full burden and does well by disclosing that it uses pure Python httpx requests (no subprocess), performs no mutations, and requires allowed_hosts configuration. This gives strong transparency into behavior and safety.

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?

Well-organized with clear sections for summary, checks, args, returns, and notes. Every sentence adds value and the structure makes it easy to scan without unnecessary 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?

Covers purpose, parameters, return values (also supported by output schema), prerequisites, and safety profile. No obvious gaps for a tool of this 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?

The 'Args' section explains every parameter (url, check_introspection, authenticated, auth_header, timeout) with examples and semantics, fully compensating for the 0% schema description 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?

Clearly states it 'Perform automated GraphQL security checks' and lists specific check categories (introspection, query batching, depth limit, field suggestion), which distinguishes it from general-purpose scanners among sibling tools.

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

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

Provides clear context for GraphQL security testing and includes practical notes like allowed_hosts requirement, but does not explicitly contrast with alternative tools or state when not to use it.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It discloses that it uses dictionary attacks via John or Hashcat, explains the 'auto' tool preference order, and warns about authorized use only. It does not mention potential resource usage, prerequisites, or side effects, leaving some gaps in transparency. Overall, it provides moderate behavioral context.

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

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

The description is well-organized and front-loaded, starting with a clear one-sentence purpose followed by an important naming note. The Args section is concise and informative, and the notes add valuable caveats. Slight repetition of the hash_value naming warning occurs, but it reinforces a critical detail without being bloated.

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

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

Given the presence of an output schema and the detailed parameter explanations, the description is fairly complete. It covers the tool's purpose, parameters, usage notes, and ethical considerations. It lacks explicit alternative tool guidance and some operational details, but for a hash cracking tool, it provides sufficient context for an agent to use 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?

The input schema itself provides no descriptions (0% schema coverage), but the tool description thoroughly explains every parameter with defaults and examples. For instance, hash_value is accompanied by a critical naming note and an example, and tool_preference is explained with its enum values. This fully compensates for the missing schema descriptions, making parameter semantics excellent.

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

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

The description clearly states 'Attempt to crack a hash using a dictionary attack,' specifying the verb, resource, and method. It mentions the underlying tools (John the Ripper, Hashcat), which clarifies its function. However, it does not explicitly differentiate itself from sibling tools like hydra_attack or hash_identify, so it falls short of a 5.

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

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

The description provides some usage context, such as 'Only use for authorized password recovery or testing purposes' and notes that dictionary attacks may not work against strong passwords. It also advises that hashcat is preferred for GPU-accelerated cracking. However, it does not explicitly state when to use this tool versus alternatives like hash_identify or hydra_attack, so the guidance is implied rather than explicit.

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

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

With no annotations provided, the description carries full burden. It discloses the pattern-matching approach, output (list of possible types with confidence scores and hashcat modes), and the critical parameter naming requirement (hash_value not hash). It lacks details on edge cases or errors, but for a read-only analysis tool, this is sufficient.

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

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

The description is well-structured with clear sections (description, IMPORTANT note, Args, Returns). Every sentence adds value, and the repeated emphasis on the parameter name is purposeful for correctness. No unnecessary fluff.

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

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

Given a single parameter, an output schema (not shown but referenced), and no annotations, the description explains the return format (list of types with confidence and hashcat mode numbers) and the tool's behavior. It is complete for this simple tool's context.

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 fully compensates by explaining that the parameter is the hash string, must be named 'hash_value', and provides an example. This is significantly more informative than the bare schema.

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

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

The description clearly states the tool identifies the algorithm used to produce a hash value, with a specific verb ('Identify') and resource ('hash value'). It distinguishes from sibling 'hash_crack' by focusing on identification, not cracking.

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

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

The description provides clear context: it is used to identify hash types via pattern matching. It includes an explicit 'IMPORTANT' note on how to call the tool and what to expect. However, it does not explicitly mention when NOT to use it or direct users to alternatives like hash_crack for cracking, so some implicit inference is required.

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

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

No annotations are present, so the description must carry the burden of behavioral context. It discloses that it uses the ProjectDiscovery httpx CLI (not the Python library), has a threads parameter with max 200, and requires the target to be in tengu.toml allowed_hosts. It also states return output includes status codes, titles, and detected technologies. This goes beyond the schema, though it could be more explicit about network side effects.

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

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

The description is well-structured with a summary, argument list, returns, and notes. It is front-loaded with purpose and contains no filler—each line provides value, including the note distinguishing from the Python httpx library.

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

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

The description is complete for a tool with an output schema: it covers purpose, all parameters, output highlights, and a critical configuration constraint. The minor ambiguity of 'host or URL list' in the opening line is clarified in the Args section with 'Target URL or host.'

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?

All four parameters are described in the Args section: target with an example, threads with default and max, detect_tech with default, and timeout as an override. This fully compensates for the 0% schema description coverage, adding meaning well beyond type and default.

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

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

The description opens with 'Probe HTTP services on a host or URL list using ProjectDiscovery httpx,' which uses a specific verb (probe) and resource (HTTP services). It further details capabilities like technology detection, status code enumeration, and title extraction, making it distinct from siblings like nmap_scan (network scanning) or katana_crawl (web crawling).

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

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

The description provides a clear use case: 'Useful for quickly triaging large host lists after subdomain enumeration.' This implicitly tells the agent when to select this tool over others, though it does not explicitly state alternatives or exclusions. The note about allowed_hosts also gives context for when it can be used.

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

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

With no annotations provided, the description carries full behavioral disclosure. It states the tool downloads the entire website, preserves structure, caps depth at 5, caps max_size at 500 MB, supports timeout overrides, requires HTTrack installation, and enforces the allowed_hosts constraint. It also summarizes the return contents, providing comprehensive behavior beyond 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?

The description is well-structured with clear sections (summary, useful-for, args, returns, note) and front-loads the core purpose in the first sentence. It is somewhat lengthy, but each section provides necessary information without redundant fluff, so it remains efficient 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?

Despite having no annotations, the description covers purpose, usage scenarios, all parameters, output summary, prerequisites (HTTrack installed, allowed_hosts), and safety caps. Since an output schema exists, the return values are sufficiently described. The description is complete for an agent to select and invoke the tool correctly.

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

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

The input schema has 0% description coverage, but the 'Args' section in the description explains all 6 parameters: target, depth, output_dir, max_size, include_assets, and timeout, including defaults, ranges, and constraints. This fully compensates for the lack of schema 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?

The description opens with 'Mirror a website locally for offline analysis using HTTrack' and elaborates on downloading the full site (HTML, JS, CSS, images), which clearly specifies the verb, resource, and purpose. It also lists concrete use cases that differentiate it from sibling tools like katana_crawl (crawling) or gowitness_screenshot (screenshots).

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 includes a 'Useful for' section with three explicit scenarios (forensic snapshots, offline secret search, mapping structure) and advises setting depth=1 for a shallow mirror. It provides clear context on when to use the tool, though it does not explicitly name alternative tools or state when not to use it.

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

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

The description is highly transparent about behavioral consequences: it warns of account lockouts, IDS/IPS alerts, log entries, and the need for authorization. Since there are no annotations, this description fully carries the burden of disclosing the destructive nature of the operation, going beyond simple 'mutating' labels.

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

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

The description is well-organized into warning, args, returns, and notes. It is a bit long but every sentence adds necessary safety or usage context. It is front-loaded with the core action and warning, making it efficient.

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

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

For an attack tool with 8 parameters and no annotations, the description is robust: it covers purpose, all parameter meanings, output (list of discovered credentials), and critical prerequisites (authorization, allowed host). This is sufficient for an agent to invoke it correctly, and the note about rate limiting adds responsible usage guidance.

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 'Args' section provides a one-line explanation for each of the 8 parameters, including defaults and limits (e.g., 'threads' default 16, max 64). This meaningfully supplements the input schema, which only lists names and types, giving the agent guidance on how to set each 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 opens with a clear verb-object directive: 'Perform a credential brute force attack using Hydra.' It names the specific tool and attack type, distinguishing it from other scanning/attack tools in the sibling list. This establishes a precise purpose.

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

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

It provides explicit authorization requirements and warnings about destructive impact ('Only use with explicit written authorization', 'Requires explicit human authorization before execution'). It also notes the target must be in an allowed_hosts list, giving clear invocation constraints. However, it does not name alternative tools for when not to use it, so it stops short of a 5.

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

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

With no annotations provided, the description carries the burden. It discloses that the tool makes TGS requests (network behavior), warns about EDR/SIEM detection, notes password redaction in logs, and requires an allowed host – all useful behavioral context. It does not detail side effects or error scenarios, but the key risk is covered.

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

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

The description is well-structured with a clear introductory sentence, an Args section that is concise, a Returns note, and a WARNING section. No redundant text; each sentence provides necessary information.

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

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

The description covers the core function, expected outputs (service accounts, SPNs, TGS hashes), and important warnings (detectability, credential requirement, allowed hosts). However, it does not explicitly state that either password or hashes must be supplied (both are optional in the schema) or clarify the default timeout value. Given the output schema exists, this is adequate but not exhaustive.

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 zero descriptions (0% coverage), but the description explains every parameter: target (DC IP), domain (AD domain), username (valid domain user), password (authentication), hashes (NTLM format LM:NT, alternative), and timeout (override default). This fully compensates for the schema gap.

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

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

The description clearly states it performs Kerberoasting using Impacket GetUserSPNs, specifically requesting TGS tickets for service accounts with SPNs. This distinguishes it from sibling tools like impacket_secretsdump or psexec.

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

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

It outlines prerequisites (valid domain credentials, allowed target) and the outcome (offline-crackable hashes), but does not explicitly compare against alternatives or state when not to use it. The usage context is implied rather than fully specified.

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

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

With no annotations provided, the description carries full burden and excels. It discloses destructive behavior, creation of a service, high detectability (Event IDs 7045, 4688), authentication requirements, and password redaction in logs. This goes well beyond a simple 'runs a command' and fully informs the agent of consequences.

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

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

The description is well-structured with 'Args', 'Returns', and 'WARNING' sections, front-loading the core purpose. Each sentence earns its place, and the warnings are essential for a destructive tool. No redundancy or 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?

Despite having no annotations and 7 parameters, the description covers purpose, mechanism, prerequisites, authentication methods, detection risk, and return type. An output schema exists, so the vague 'Returns' line is acceptable. This is a complete, self-sufficient description for a complex 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. It does so by listing all 7 parameters with meaningful context: target, domain (with '.' for local accounts), username, command, password (redacted), hashes (LM:NT format for pass-the-hash), and timeout override. This adds value beyond bare schema fields, though some descriptions remain terse.

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

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

The description clearly states 'Execute a command remotely on a Windows host via SMB using Impacket psexec' with a specific verb, resource, and method. It also explains the underlying mechanism (uploads a service binary, creates/starts a Windows service), which distinguishes it from sibling tools like impacket_wmiexec or impacket_secretsdump.

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

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

The description provides clear context: requires admin credentials and SMB access (port 445), is destructive, and demands explicit human authorization. It implies when to use by describing the command execution scenario, but it does not explicitly contrast with alternatives such as WMI exec or mention when not to use it.

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

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

With no annotations provided, the description fully discloses behavioral traits: it is destructive/intrusive, detectable by EDR, requires admin credentials and explicit human authorization, and targets must be in allowed_hosts. It also notes that the password is redacted in logs and returns data organized by type. This is comprehensive for a security tool with no annotation support.

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

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

The description is well-structured with clear sections (summary, args, returns, warnings). It front-loads the core purpose, uses bullet points for parameters and warnings, and every sentence adds value. The length is appropriate 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?

Despite having an output schema, the description still explains return values and includes essential warnings and prerequisites. Combined with the parameter details and clear purpose, it provides a complete picture for an agent to decide when and how to invoke this tool, even among many siblings.

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%, but the Args section gives meaningful explanations for every parameter: target (IP/hostname), domain (use '.' for local), username, password (redacted in logs), hashes (LM:NT format for pass-the-hash), and timeout. This fully compensates for the schema's lack of 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?

The description opens with a specific verb and resource: 'Dump SAM, NTDS, and LSA secrets from a Windows target using Impacket secretsdump.' This clearly distinguishes it from sibling impacket tools like impacket_kerberoast, impacket_psexec, and impacket_smbclient, which target different functionalities.

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

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

The description provides clear context for when to use the tool: to extract credential hashes from Windows systems. It also lists prerequisites (admin credentials, allowed_hosts, human authorization) that act as usage constraints. However, it does not explicitly name alternatives or state when not to use this tool, so it misses the top score for explicit 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?

With no annotations provided, the description takes on the full burden of behavioral disclosure. It explains authentication options (password vs. NTLM hashes), mentions that password is 'redacted in logs', and states target restrictions and permission requirements. It does not explicitly note that listing operations are safe/read-only, but the action choices (list_shares/list_files) make that implicit. This is solid but not exhaustive.

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

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

The description is front-loaded with the purpose in the first two sentences, followed by a clear Args list, Returns, and Note sections. Each sentence carries useful information—there is no filler. Despite listing 8 parameters, it remains scannable and well-formatted.

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

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

Given 8 parameters, no annotations, and an output schema that exists, the description covers all essential aspects: purpose, parameter semantics, authentication methods, prerequisites, and what the tool returns ('SMB shares list or file listing'). It also warns about the required target allowlist and permission needs, providing sufficient context for an AI agent 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?

The input schema has zero descriptions, so the description's Args section is essential. It fully explains all 8 parameters: target, domain, username, action, share, password, hashes, and timeout. For example, it clarifies the action enum values, the share name format (e.g., 'C$', 'ADMIN$'), and the hashes format 'LM:NT'. This exceeds the schema's 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?

The description clearly states the tool's purpose: 'Browse and interact with SMB shares' and specifically 'Enumerates available shares and optionally lists files within a specific share.' This distinguishes it from siblings like impacket_psexec or impacket_secretsdump, which handle remote command execution or credential dumping, respectively.

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 conveys clear context for use: SMB share enumeration and file listing. It also provides prerequisites via the note: 'Target must be in tengu.toml [targets].allowed_hosts' and 'Requires valid credentials with appropriate share permissions.' However, it does not explicitly name alternatives or state when not to use it, so it falls short of a full 5.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It usefully discloses WMI access ports, admin requirements, Event ID 4688 generation, WMI activity logs, password redaction, and the need for explicit human authorization. It does not mention limitations such as command output truncation or the exact command interpreter used.

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

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

The description is well-structured with a summary, args list, returns section, and warnings. The first sentence is front-loaded and precise. While slightly longer than minimal, every section adds useful information and there is no filler.

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

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

For a high-risk remote command execution tool, the description is reasonably complete: it covers purpose, prerequisites, network ports, logging side effects, return behavior, and authorization requirements. It falls slightly short by not addressing authentication precedence when both password and hashes are supplied, or whether the command runs via cmd.exe or PowerShell.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining all seven arguments. It adds meaningful details such as using '.' for local accounts, password redaction in logs, hashes format 'LM:NT' for pass-the-hash, and timeout as an override in seconds.

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

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

The description opens with a specific verb and resource: 'Execute a command remotely on a Windows host via WMI using Impacket wmiexec.' It clearly distinguishes itself from impacket_psexec by noting it is 'stealthier than psexec as it does not create a service.'

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

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

The description gives clear usage context by contrasting wmiexec with psexec and stating it avoids service creation. It also lists prerequisites such as 'admin credentials and WMI access (port 135/445)' and 'explicit human authorization.' However, it does not explicitly state when not to use this tool or mention other alternatives beyond psexec.

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

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

With no annotations, the description carries the disclosure burden. It mentions JavaScript rendering, form submission, scope-aware crawling, and timeout override, but does not disclose potential network load/noise, authentication requirements, or a safety profile. It implies active crawling but could be more explicit about impact.

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?

Well-structured: one-sentence summary, brief tool context, clear argument list, return description, and a note. No fluff; every line adds 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?

Description provides the core function, tool background, parameter semantics, return value summary, and an important scope constraint. It doesn't elaborate on output schema (but that's handled by output schema) or mention alternatives, but overall it's sufficiently complete for an agent to select and invoke 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 has zero descriptions, but the Args section fully explains every parameter: target, depth (with default/max), concurrency (with default/max), js_crawl (purpose), and timeout (meaning). This directly compensates for the schema's lack of documentation.

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

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

The description opens with a specific action verb ('Crawl a web application to discover endpoints and URLs') and names the underlying tool (Katana). It further distinguishes from sibling scanners by noting JavaScript rendering, form submission, and scope-aware crawling capabilities, which are unique differentiators.

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 first sentence clearly states the tool's purpose (crawling to discover endpoints and URLs). The note about target needing to be in allowed_hosts is a clear prerequisite. However, it does not explicitly compare to alternatives or provide when-not-to-use scenarios.

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

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

With no annotations, the description carries full responsibility. It discloses high-rate risks ('may trigger IDS/IPS alerts or crash routers'), root requirement, allowed_hosts constraint, and the lack of service detection. These go well beyond the input schema and prepare the agent for real-world consequences.

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

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

The description is organized with clear sections (description, Args, Returns, Notes) and every sentence adds value: trade-offs, parameter examples, warnings, and prerequisites. It is appropriately detailed for a security tool with four parameters and significant operational caveats, with no redundancy.

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

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

For a tool requiring root, sending raw packets, and running against potentially large networks, the description covers prerequisites (root, allowed_hosts), behavior limitations (no service detection), safety (rate guidance), and return format. It leaves no critical gap given the complexity and absent schema descriptions.

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?

Input schema has 0% description coverage, so the Args section compensates fully. It explains target with an example CIDR, ports with formats, rate with warning guidance, and timeout as an override. This adds semantic meaning beyond raw JSON types, directly addressing each 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 opens with a specific verb+resource: 'Scan a network range for open ports at high speed using Masscan.' It explicitly distinguishes from Nmap via 'significantly faster ... but produces less detailed results (no service detection)', which differentiates it from the sibling nmap_scan tool.

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

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

Provides clear guidance: 'Ideal for initial port discovery across large IP ranges' and notes the trade-off vs Nmap. It also includes prerequisites like root/sudo, target whitelist in tengu.toml, and rate recommendations for stealth, giving both when-to-use and operational conditions.

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

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

With no annotations, the description carries the burden of disclosing behavior. It clearly states the tool is informational ('Get detailed information') and lists what is returned (options, targets, CVE references, description). This sets expectations that it is a read-only lookup, not an execution tool. It does not mention potential errors or prerequisites, but for a benign info query, the description provides sufficient transparency.

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

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

The description is concise and well-structured: a clear one-sentence purpose, then an Args section for the parameter, and a Returns section for the output. No unnecessary words or repetition. It is front-loaded with the core purpose.

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

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

The tool is simple (one parameter) and an output schema exists, so the description doesn't need to explain return structure. It covers the essential aspects: what the tool does, the input format with example, and a summary of the return content. It could add a note about module validity or local vs remote lookup, but given the complexity, it is adequately 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?

The schema only lists 'module_path' as a string with no description, giving 0% coverage. The description fully compensates by explaining that it is the 'Full module path' and providing a concrete example. This gives the agent all necessary information to correctly populate the parameter.

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

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

The description clearly states the tool's function: 'Get detailed information about a specific Metasploit module.' It uses a specific verb ('Get') and resource ('specific Metasploit module'), and the example path demonstrates the exact scope. This distinguishes it from sibling tools like msf_search (which searches for modules) and msf_run_module (which executes modules).

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

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

The description implies when to use this tool: when you need detailed info about a specific module, as indicated by 'Get detailed information' and the return listing. It does not explicitly mention alternatives or exclusions, but the context is clear enough for a simple lookup tool. A brief note about using msf_search to find module paths would elevate it to a 5, but it is not necessary for basic usage.

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

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

With no annotations, the description carries the full burden and does so excellently. It explicitly warns that the operation is destructive, may exploit vulnerabilities, requires human confirmation, and initiates an actual exploit attempt against the target. This goes beyond basic mutation disclosure and covers the critical safety and authorization context.

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

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

The description is well-structured with clear sections for arguments, returns, and usage warnings. It is appropriately detailed for a complex, high-risk tool without being verbose or redundant. Each sentence contributes critical information, from parameter examples to authorization requirements.

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

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

Given the high complexity, absence of annotations, and presence of an output schema, the description is remarkably complete. It covers all parameters, explains return value semantics, and clearly warns about authorization and destructive potential. The output schema handles exact return formatting, so the description appropriately focuses on behavior and prerequisites.

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%, but the description compensates fully with detailed explanations for all five parameters: module_path with example, options as key-value pairs, target_index with default, payload with examples and behavior when empty, and payload_options with clarifications. It adds semantic meaning far beyond the schema's raw type definitions.

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

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

The description clearly states the tool's purpose: 'Execute a Metasploit module with configured options.' This is a specific verb+resource pairing that distinguishes it from sibling tools like msf_search or msf_module_info, which focus on discovery and metadata rather than execution.

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 clearly communicates the high-risk context: destructive operation, requires explicit authorization and human confirmation. It implies this is for actual exploitation rather than reconnaissance. However, it does not explicitly name alternatives like msf_search for finding modules or msf_module_info for detailing options, so it falls short of full sibling differentiation.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states the return format ('name, rank, and description'), but does not disclose any limitations, prerequisites, or potential side effects, which are minimal for a search tool.

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

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

The description is concise and well-structured, with a one-sentence purpose and labeled Args/Returns sections. Every sentence provides useful information without redundancy.

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

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

For a simple search tool with an output schema, the description covers the core functionality, parameters, and return values. It lacks only non-critical details like error handling or result limits, so it 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?

The description fully explains both parameters with examples and enumerates allowed module_type values, compensating for the 0% schema coverage. It adds meaning beyond the raw schema types.

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

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

The description clearly states 'Search for Metasploit modules matching a query' with a specific verb and resource. It distinguishes itself from sibling tools by focusing on Metasploit modules, though it does not explicitly contrast with similar search tools like searchsploit_query.

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 use this tool versus alternatives like searchsploit_query or cve_search. The examples (e.g., 'eternalblue') imply vulnerability research context, but no when/when-not guidance is provided.

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