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

No annotations are provided, so the description carries the burden of disclosing behaviors. It states that the tool 'cracks' keys (implying intensive computation), requires specific capture conditions, and that the output is the cracked password. However, it doesn't disclose potential limitations like the need for sufficient IVs (mentioned but not quantified) or that running this tool may be illegal without permission—though that's context not necessarily required. The description is adequate 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 concise (three sentences) and front-loads the core purpose, then provides usage conditions and alternatives. Every sentence contributes value, with 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?

Given that the tool is complex (requires specific capture files) but has 100% schema coverage and an output schema is absent, the description covers the essential prerequisites (handshake/IVs), the role of wordlist, and the output. It doesn't mention failure cases (e.g., password not found) or time expectations, but for a security tool, this is acceptable.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by clarifying that the wordlist is required for WPA cracking and that without it only WEP works. It also gives an example of the opts parameter. This goes beyond the schema's minimal 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: cracking WiFi keys (WEP, WPA/WPA2-PSK, WPA3) from captured traffic, and specifies the required input (a .cap file with handshake/IVs). It also explicitly distinguishes itself from related tools (wifite, reaver).

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 conditions for use (requires a .cap with 4-way handshake for WPA, etc.) and names alternatives (wifite for automating, reaver for WPS attacks). This helps the agent decide when to choose this tool over siblings.

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

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

With no annotations provided, the description carries the full burden. It discloses the tool's methodology (OSINT + active DNS brute-force), the speed tradeoff, and the output format ('discovered assets with their sources and relationships'). It doesn't mention potential network load or alerting from active techniques, but it gives enough behavioral context for safe selection.

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

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

Three dense sentences, front-loaded with the core purpose, followed by usage guidance and output. Every clause earns its place—there is no fluff or redundant restating of the tool name.

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

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

For a tool with an output schema absent, the description covers purpose, method, usage context, alternatives, and output. It lacks an example invocation or notes on prerequisites (e.g., API dependencies for OSINT sources), but the definition is otherwise self-sufficient 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?

Schema description coverage is 100%, so the baseline is 3. The description does repeat the active/passive distinction that maps to opts ('-active'), but it adds no new parameter-level detail beyond what the schema already documents. The description doesn't explain mode='intel' further, but the schema already covers it.

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

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

The description uses specific verbs and concrete resources: 'Comprehensive network mapping and attack surface discovery', 'Discovers subdomains, IP ranges, ASNs, and related domains.' It explicitly contrasts itself with subfinder ('More thorough than subfinder but slower'), making it distinguishable from the closest sibling without opening the schema.

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

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

It explicitly states when to use this tool ('Use for deep domain mapping'), describes its methodology, and provides a direct alternative and condition: 'Use subfinder for quick passive-only results.' The description leaves no ambiguity about tool selection between amass and subfinder.

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 behavioral burden. It discloses the active mechanism (sends ARP requests), scope (local network segment), and return fields, but it does not mention prerequisite privileges, interface behavior beyond auto-detection, or side effects of active scanning.

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

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

Three sentences with no filler: purpose, use case/comparison, and output are each in their own sentence, and the most decision-relevant message (purpose + faster than nmap) comes first.

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

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

For a straightforward scanning tool with three fully documented parameters and no output schema, the description is nearly complete: it states method, scope, output format, and choice over nmap. The remaining gap is an explicit note on required privileges or interface 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 100%, so the schema already documents all three parameters (opts, iface, target) with examples. The description adds no parameter-specific detail, which is acceptable given the schema's completeness.

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?

Description names a specific verb and resource: 'ARP-based host discovery', explicitly states it sends ARP requests and identifies live hosts by MAC address and vendor, and lists the output fields. This clearly distinguishes it from sibling scanners like nmap and masscan.

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?

States a concrete use case: 'Use for initial reconnaissance of a local subnet' and positions it against nmap ('faster and more reliable than nmap ping scans on the same LAN'). It does not spell out when not to use it, but the guidance is clear enough for an agent to route correctly.

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 disclosing behavior. It does disclose that this is an active attack/Manipulation tool and describes outputs such as captured credentials, session cookies, and traffic logs. However, it omits operational caveats like required privileges, network disruption risks from ARP/DNS spoofing, or the fact that traffic manipulation can have 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 compact and well-structured: it opens with the core purpose, lists key techniques, states the intended use case, and closes with concrete outputs. Every sentence adds useful information without repetition 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?

For a tool with all-optional parameters and no output schema, the description provides enough context for correct invocation: what it does, when to use it, and what to expect as output. It lacks details about how caplets/options map to workflows or prerequisites, but the schema fills the parameter gap and the overall context is 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 covers all three parameters (opts, iface, caplet) with 100% description coverage, so the baseline is 3. The tool description mentions 'modular caplets' generally but does not add parameter-specific guidance beyond what the schema already provides.

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

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

The description clearly identifies bettercap as a real-time MITM attack framework and enumerates specific capabilities (ARP spoofing, DNS spoofing, HTTP/HTTPS manipulation, credential sniffing, session hijacking). This makes its purpose unmistakable and differentiates it from recon/scanning siblings like nmap, tcpdump, or sqlmap.

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 explicitly states when to use the tool: 'Use for man-in-the-middle attacks on a local network segment.' It does not explicitly mention exclusions or name alternatives, but the stated context is clear enough for an agent to route toward this tool rather than a scanner or exploit framework.

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 the key behavior: automatic extraction when -e is used (and -e is the default per the schema), and describes the output as an offset map and extracted file paths. It does not mention potential side effects like file writing location or permission needs, but the core behavior is transparent. This is adequate for a read/extract 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?

Four sentences with no fluff. The purpose is front-loaded, followed by the extraction behavior, then use cases, and finally the output format. Every sentence contributes essential 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 tool with no output schema and no annotations, the description covers the main aspects: what it does, when to use, how it behaves (extraction), and what output to expect. It lacks details like output file locations or potential limitations, but it is complete enough for an agent to decide when to invoke it. The parameter hints add to completeness.

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

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

Schema description coverage is 100%, so both parameters are documented. The description adds value beyond the schema by clarifying the default -e behavior and suggesting -M for recursive scanning. This goes beyond simple field names and helps the agent understand typical usage patterns.

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?

Description clearly states the tool's function: scanning binary files for embedded signatures, compressed data, and filesystem structures. It names the specific resource (binary/firmware files) and the verb (scan), and distinguishes it from the network/security siblings by focusing on firmware analysis and file extraction. The use case is explicit: reverse engineering firmware images and IoT 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 on when to use: for reverse engineering firmware, IoT binaries, or blobs with embedded files. It does not explicitly name alternative tools, but given the sibling list (e.g., foremost for file carving), a brief differentiation would be beneficial. However, the stated use cases are sufficient for an agent to select this tool appropriately.

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 of behavioral disclosure. It discloses that the tool spiders a website and can save output to a file, but it does not mention potential network impact, rate limiting, or whether it respects robots.txt. For a network-scanning tool, this is a moderate gap, though the core behavior is 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 tightly packed with no filler. It front-loads the core function, then adds usage guidance, a contrast to a sibling, and a note on output—all in a few sentences. Every sentence earns its place.

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

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

The tool has 5 parameters (all schema-documented), no output schema, and no annotations. The description covers purpose, usage, alternative, and output format. It does not mention prerequisites or edge cases, but for a straightforward spidering tool, the provided context is sufficient for an agent to call it correctly.

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

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

Schema coverage is 100% with every parameter described in the input schema. The description does not add extra meaning beyond the schema; it only implies the tool's purpose. According to the rubric, a baseline of 3 is appropriate when the schema handles parameter 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 precise verb+resource: 'spiders a website and extracts words from its content.' It explicitly differentiates from the sibling tool crunch by contrasting website-content extraction with character-set/pattern generation, so an agent can select it unambiguously.

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

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

The description states exactly when to use this tool ('when you have a target website') and explicitly names the alternative (crunch) for non-website cases. It also lists downstream tools (hydra, john, hashcat) that consume the output, providing clear context for invocation.

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 burden. It discloses that it encapsulates TCP connections inside HTTP WebSocket streams, which is a key behavioral trait. It also mentions output (connection status and tunnel statistics). However, it doesn't disclose potential side effects like network traffic patterns, persistence, or whether it modifies the system. For a tunneling tool, this is moderate transparency but not comprehensive.

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

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

The description is compact and front-loaded with the core purpose. It covers the key points (protocol, use case, deployment roles, output) in a few sentences. Slightly dense but every sentence earns its place. Could be slightly more structured but overall efficient.

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

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

For a tool with 5 parameters and no output schema, the description covers the essential context: what it does, when to use it, how to deploy it (server/client roles), and what output to expect. It doesn't explain all parameter combinations in detail, but the schema covers parameter semantics. The description is complete enough for an agent to invoke it correctly in a typical pivoting scenario.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters. The description adds context for server/client roles and mentions reverse port forwarding, which helps interpret the 'server' and 'port' parameters. However, it doesn't add much beyond the schema's own descriptions, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: a fast TCP/UDP tunnel over HTTP/HTTPS for pivoting through firewalls and NAT. It names the specific verb (tunnel), the resource (TCP/UDP traffic), and the context (pivoting through firewalls/NAT), which distinguishes it from sibling tools like netcat or proxychains.

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 explicit usage context: run server on attack box, client on pivot host with reverse port forwarding. It also mentions the ideal scenario (tunneling from internal network through compromised host). However, it doesn't explicitly state when not to use it or name alternatives, though the context is clear enough for an agent to select it appropriately.

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 carries the behavioral burden. It discloses that the tool detects and exploits command injection, supports results-based/blind/time-based techniques, and can open an interactive pseudo-shell on success. It stops short of warning about the potentially intrusive/destructive nature of exploitation, but the core behavior is clearly conveyed.

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

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

Three sentences, each carrying distinct value: what it does, when to use it, and what the output looks like. There is no filler or repetition of schema fields.

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

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

For a two-parameter tool with full schema coverage and no output schema, the description covers purpose, selection criteria, injection techniques, and success output. It could be slightly more complete by noting prerequisites or a safety caveat, but nothing essential to invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents the url and opts parameters, including a default value for opts. The description does not add parameter-level detail beyond the schema, so the baseline 3 applies.

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

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

The description opens with a specific verb and resource: 'Automated OS command injection detection and exploitation tool.' It names the exact input surfaces (HTTP parameters, headers, cookies, POST data) and explicitly distinguishes itself from sqlmap, so an agent can identify what commix does without opening the schema.

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

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

It provides an explicit decision rule: 'Use when sqlmap confirms the parameter is NOT SQL injectable but may still be vulnerable to command injection.' This names the sibling tool and the condition that selects commix, and no other alternative is needed because commix is the dedicated command-injection tool in the sibling set.

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?

Even without annotations, the description discloses the tool's active and potentially intrusive behavior: it exploits services, supports pass-the-hash/Kerberos, and executes modules like lsassy and mimikatz. It also states what output to expect. It does not fully detail side effects or authorization requirements, but it conveys enough behavioral context for an agent to treat it as an active exploitation 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 dense yet well-structured: identity and scope first, then capabilities, then usage guidance and alternatives, then output summary. Every sentence earns its place, and there is minimal filler for a tool with this breadth.

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

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

For a complex multi-protocol tool with 7 parameters and no output schema, the description is quite complete: it covers protocols, auth modes, modules, when to use it, alternatives, and expected output. It could add a brief note on required credentials or safety implications, but the core operational context is present.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds value by giving concrete module examples (lsassy, mimikatz, spider_plus) and highlighting pass-the-hash and Kerberos modes, which maps to ntlm_hash and opts. This goes beyond the baseline without fully replacing schema details.

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

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

The description clearly identifies the tool as a pentesting Swiss-army knife for Windows/AD environments and names the specific protocols and actions it performs (enumerates/exploits SMB, WinRM, MSSQL, RDP, SSH, FTP; supports pass-the-hash and Kerberos). It also differentiates itself from siblings by positioning itself as the primary post-exploitation tool and explicitly calling out evil_winrm and enum4linux as alternatives.

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

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

The description gives explicit usage direction: use as the PRIMARY post-exploitation tool against Windows networks when you have credentials. It also provides clear when-not-to-use guidance by naming evil_winrm for interactive WinRM shells and enum4linux for detailed SMB enumeration.

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 full behavioral disclosure burden. It discloses the output destination ('Output: wordlist printed to stdout or written to a file') and mentions the use of character sets and patterns. It does not detail potential side effects or performance implications, but as a generator it is inherently non-destructive and the main behavior is adequately described.

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

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

The description is three concise sentences, front-loaded with the core purpose, then usage guidance, and finally output behavior. Every sentence adds value with no redundancy, making it efficient for an agent to parse.

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

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

For a tool with 5 well-documented parameters and no output schema, the description covers the essential context: purpose, usage conditions, alternative tool, and output destination. It lacks details on potential constraints (e.g., maximum length limits, charset restrictions) but these are minor and the schema covers the parameters. Overall it is sufficiently complete for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds semantic value by explaining how the parameters combine ('based on character sets, length ranges, and patterns') and gives a concrete example for the 'opts' parameter ('-t @@@%%%' for pattern), which clarifies the intended usage 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's purpose: 'Wordlist generator — creates custom password lists based on character sets, length ranges, and patterns.' It uses a specific verb ('creates') and resource ('custom password lists') and explicitly distinguishes from the sibling cewl, making it unambiguous which tool to pick.

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 when-to-use guidance: 'Use to generate targeted wordlists when you know password policy (min/max length, required characters).' It also gives an alternative and when-not-to-use: 'For generating wordlists from website content (password profiling), use cewl instead.' This fully covers usage 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 present, the description carries the disclosure burden. It reveals key behavior: dictionary-based attacks, output as found paths with HTTP response codes, and non-recursive by default. It could mention network side effects or permission needs, but the scanner nature is evident.

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

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

The description is compact and front-loaded, starting with the scanner type, then comparing to gobuster, giving a usage rule, and stating the output and recursion default. Every sentence adds 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?

Given three simple parameters and no output schema, the description covers the main operational details: output format and default recursion behavior. It leaves minor gaps, such as explicit recursion override or authorization warning, but is sufficient for a straightforward scanner.

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

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

The input schema already describes all three parameters with 100% coverage, so the baseline is 3. The description adds only 'built-in wordlists' context and does not materially deepen parameter meaning beyond the schema.

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

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

The description states a specific action and resource: a dictionary-based web content scanner that finds hidden directories and files. It also distinguishes itself from the gobuster sibling, so an agent can tell it apart from 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 gives explicit guidance: 'Use when you want a straightforward directory scan without configuring many options' and positions it as simpler than gobuster. It provides clear context for when to choose it, though it does not explicitly list exclusions or when to prefer other siblings.

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

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

The description is transparent about the active network behavior — zone transfer attempts, brute-force discovery, reverse lookups — and states what the output looks like. However, with no annotations provided, it does not disclose whether this tool is noisy or rate-limited, whether authorization/network access is expected, or any other operational 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?

Three sentences, each with a distinct job: capabilities, use case/alternative, and output. There is no redundant restatement of the tool name or parameter schema.

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

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

For a two-parameter tool with no output schema, the description covers why to use it, when to use it, what it does, and what to expect back. It could add an explicit example or operational caveat, but nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description reinforces the domain use case and lists record types, but it adds no new semantic detail beyond what the input schema already provides for domain and opts.

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

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

Names a concrete resource ('DNS footprint') and enumerates the exact active actions: zone transfer attempts, brute-force subdomain discovery, reverse lookups, and DNS record enumeration. This clearly differentiates it from sibling passive discovery tools like subfinder and from network scanners like nmap.

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

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

Explicitly gives the trigger condition: use when you have a domain and need to map its DNS footprint. It also provides a when-not by directing passive, multi-source subdomain discovery to subfinder.

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 that the tool operates without authentication, mentions RID-cycled user lists, and describes output structure. While it doesn't mention potential side effects like detection or service disruption, it accurately conveys the tool's read-only enumeration nature, which is sufficient for a recon 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 extremely concise, two sentences total, with the core purpose front-loaded. It avoids any redundant or filler content, and every sentence contributes to understanding the tool's scope and usage.

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 only two parameters and no output schema, the description is remarkably complete. It specifies the target protocols (SMB, ports 139/445), mentions the output type (structured enumeration data), and provides usage guidance. No critical information is missing for an agent to correctly select and invoke this tool.

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

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

The schema already describes both parameters with 100% coverage, so the baseline is 3. The description adds value by providing an example usage of the opts parameter ('-a' for all enumeration), which helps the agent understand how to use it beyond the schema's bare description. This extra context justifies a score above baseline.

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

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

The description clearly states the tool's function as a Windows/Samba enumeration tool, lists specific data types extracted (user lists, shares, groups, password policies, OS info), and explicitly distinguishes it from more advanced tools like crackmapexec and impacket. This provides a clear, specific verb-resource pair and differentiates from siblings.

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

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

The description explicitly states when to use this tool ('Windows domain reconnaissance without authentication') and when not to (when credentials are available, use crackmapexec or impacket). This gives clear direction on tool selection, leaving no ambiguity for the agent.

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 behavioral disclosure burden. It does well by revealing the evasion layers, process migration behavior, and the exact output format (saved file path with size and msfvenom warnings). It doesn't mention prerequisites or error conditions, but the core behavioral profile is clearly communicated.

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

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

Three dense sentences, all earning their place: purpose, usage guidance, and output. It is front-loaded with the core purpose and avoids redundancy, making it easy for an agent 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?

This is a complex 15-parameter tool with no output schema, so the description needs to fill gaps. It covers the essential context: what the tool does, when to use it, and what it returns. Minor omissions like prerequisite dependencies on msfvenom and potential failure conditions keep it from a 5, but overall it is complete enough for correct tool selection and invocation.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema. The description adds high-level context by grouping techniques (encoding, encryption, injection) but does not add per-parameter meaning beyond what the schema already provides. The baseline of 3 applies.

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

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

The description names a specific verb and resource ('payload crafter') and defines its exact purpose: anti-virus evasion. It enumerates concrete techniques (shikata_ga_nai, AES256, template injection) and explicitly differentiates itself from the sibling msfvenom, making the tool's identity 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 gives explicit routing guidance: 'Use INSTEAD of msfvenom when AV evasion is needed. Use msfvenom for simple/standard payload generation.' This clearly states when to use this tool and when to choose the alternative, leaving no ambiguity.

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 of behavioral disclosure. It adds value by stating the tool is interactive (creates a live PowerShell session), supports pass-the-hash, and lists the ports. It doesn't cover every edge case, but for a shell client it adequately discloses the key behavioral traits beyond what the schema already implies.

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

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

Three sentences with no wasted words. The core purpose is front-loaded, followed by usage context and an explicit alternative reference. Every sentence earns its place.

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

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

The description covers what the tool does, when to use it, the alternative, key ports, and output type. Given the 100% schema coverage for parameters and the presence of an explicit sibling reference, nothing essential is missing for an agent to call and 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?

Schema coverage is 100%, so the baseline is 3. The description mentions pass-the-hash which relates to ntlm_hash, but the schema already explains this in detail. The description does not add meaningful parameter semantics beyond what is already in the schema, so no bonus is warranted.

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 is a 'WinRM shell client' that 'provides an interactive PowerShell session' on specific ports, with pass-the-hash support. It differentiates itself from the sibling crackmapexec by specifying the interactive vs. non-interactive distinction, so an agent can tell them apart without deeper analysis.

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

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

The description explicitly says 'Use when you have valid Windows credentials and WinRM is enabled (common on servers)' and routes to the alternative 'crackmapexec with winrm protocol' for non-interactive or multi-host scenarios. This is clear, actionable guidance on when to select this tool versus a sibling.

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 full behavioral burden. It does disclose the key actions: reading, writing, editing, stripping, and modifying metadata, plus the output shape ('all metadata fields with their values'). However, it does not mention side effects like in-place file modification or failure behavior, which is a meaningful gap for a tool that can strip or alter metadata.

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

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

The description is three sentences and front-loaded with the core function. The examples are useful but slightly repetitive with the opening, and the final 'strip or modify' clause partly overlaps with 'read, write, and edit'; still, it remains focused and efficient.

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

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

For a two-parameter tool with no output schema, the description covers the input (filepath), optional behavior via opts, supported file types, application examples, and output format. It could mention error cases or destructive-call warnings, but the core information needed to invoke the tool is present.

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

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

Schema coverage is 100%, with both filepath and opts already described. The description adds useful context for file types and the general purpose, but it does not materially extend parameter semantics beyond the schema. The opts example ('-all=') appears in the schema, so no new parameter-level information is provided by the description.

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

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

The description opens with a clear verb-resource pair ('Read, write, and edit metadata') and lists concrete file types and example uses like GPS extraction and author names, making the tool's purpose unmistakable. It also distinguishes exiftool from the security/network sibling tools by focusing on file metadata rather than scanning or exploitation.

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 strong contextual cues for when to use the tool: 'Use to extract hidden information' with realistic examples such as GPS coordinates and author names. It does not explicitly name alternatives or state when not to use it, but the examples and file-type list provide clear scope.

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 the output format (matched URLs with status codes and response sizes) and implies active scanning, but does not warn about potential intrusiveness, rate limiting, or authentication requirements. It provides basic behavioral context but omits safety/operational caveats that an agent should know for an active fuzzing 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 four sentences with zero redundancy. It front-loads the core purpose, immediately gives usage guidance, then routes to alternatives, and ends with output format. Every sentence earns its place.

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

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

Given no output schema and no annotations, the description covers the essentials: purpose, usage, alternatives, output format, and key parameter semantics. It does not mention operational caveats like network scanning noise or permission requirements, but for a well-known tool with clear input schema, 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?

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the FUZZ keyword placement, giving examples for target, and clarifying the default for match_code. This goes beyond the schema's bare descriptions, particularly for the target parameter where the FUZZ concept is critical.

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 is a web fuzzer with specific capabilities (directory discovery, vhost enumeration, parameter/header fuzzing) and differentiates it from siblings like gobuster and wfuzz by naming them explicitly. The verb 'fuzz' and resource 'web' are specific and 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 explicitly tells when to use ffuf ('high-performance fuzzing tasks'), how to use it (place FUZZ keyword), and when not to use it ('simpler directory scans use gobuster or dirb', 'HTTP parameter brute-force use wfuzz'). This is exemplary guidance with named 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, the description carries the full burden of behavioral disclosure. It does state that the output is 'recovered files organized by type in the output directory', which conveys the main side effect. However, it does not mention whether the source image is modified, potential disk-space usage from recovered files, or permission requirements, leaving some behavioral gaps.

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

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

The description is three sentences with no filler. It front-loads the core purpose, then covers use cases and output in a logical order, making every sentence useful.

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 three-parameter file-carving tool with full schema coverage, the description is reasonably complete: it defines the source, output, and typical use cases. It could be more complete by covering edge behavior like handling of unrecognized file types or output directory overwrite semantics, but nothing essential for a basic call is missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters, including the default for output_dirhol and an example for opts. The description adds no extra parameter-level detail beyond what the schema provides, matching the baseline.

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

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

The description identifies a specific verb and resource: 'recovers deleted files from disk images and raw data' via 'file carving'. It clearly states the tool's function, but it does not explicitly contrast it with sibling tools such as binwalk, so it stops short of a full 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?

It clearly says when to use this tool: 'for data recovery from formatted drives, corrupted media, or when filesystem metadata is lost.' This gives an agent actionable selection context, though it does not mention when not to use it or point to an alternative.

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 behavioral burden. It does this by disclosing that the tool is a brute-force tool, that it operates in multiple modes, and that output consists of 'discovered paths/subdomains with HTTP status codes.' It does not detail load, rate, or authorization side effects, but the core active 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 three concise sentences, front-loading the tool's identity and modes, then providing alternatives and output behavior. Every sentence contributes useful selection and invocation information with no filler.

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

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

For an agent, the description is largely complete: modes, intended use, alternatives, and output format are all present. The main gap is that DNS/vhost modes typically expect a domain rather than the HTTP URL format suggested by the schema's target parameter, but this is a schema nuance rather than a prose omission. Overall, the definition is sufficient for correct tool selection.

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

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

Schema description coverage is 100%, so the baseline is 3. The description names the modes, which aligns with the 'mode' parameter, but it adds little beyond what the schema already documents. No additional parameter semantics are provided in prose.

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

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

States a specific, multi-mode purpose: 'directory/files (dir), DNS subdomains (dns), virtual hosts (vhost), and fuzzing.' It is clearly aimed at 'discovering hidden paths and subdomains,' and explicitly distinguishes itself from dirb and ffuf. An agent can immediately understand what gobuster does and how it differs from 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?

Gives explicit use guidance: use gobuster for hidden paths and subdomains, choose dirb for 'pure directory brute-force,' and use ffuf for 'parameter/header fuzzing.' This directly routes the agent to the correct sibling tool based on the task type.

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 supplied, the description carries the behavioral burden. It discloses the mandatory mode-number requirement, the output shape (cracked hashes and plaintext passwords), and the presence of status lines for speed/progress. It does not detail failure modes or GPU/OpenCL prerequisites beyond calling itself GPU-accelerated, but the key call-time behavior is 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 moderately sized but each sentence earns its place: use case, requirement, alternatives, and output behavior. The only minor excess is the marketing-style 'World's fastest' opener, but it does help convey the tool's distinguishing performance niche.

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

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

For a complex tool with no output schema and no annotations, this is reasonably complete: it covers purpose, mode requirement, alternatives, output, and progress feedback. It could add how to handle uncertain hash types (though it points to hash_identifier) and what happens with a wrong mode, but nothing essential for invoking the tool is missing.

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

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

Schema description coverage is 100%, so this dimension is baseline 3. The description reinforces that mode is mandatory and mentions output semantics, but it does not add meaning beyond the schema's property descriptions, which already include key mode values and examples in opts.

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

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

The description identifies a concrete action (high-performance cracking), a specific resource domain (hash sets), and an environment (GPU-accelerated, 300+ modes). It also explicitly contrasts itself with john, giving an agent a clear way to distinguish this offline GPU cracker from 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?

It gives a when-to-use signal ('Use for high-performance cracking of large hash sets'), a hard precondition ('REQUIRES the mode number matching the hash type'), and clear alternatives with routing conditions ('For CPU-only or auto-detect cracking, use john instead'; 'Use hash_identifier first if unsure'). This is explicit selection 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 the output format (list ranked by likelihood with hashcat mode and john format) and implies a read-only analysis. It does not mention limitations or error behavior, but it adequately conveys what the tool does and returns for an identification task.

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: states purpose, gives usage context, then output format. It is concise and front-loaded with the core function. Every sentence adds value without redundancy.

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

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

For a simple identification tool with no output schema, the description explains the output and usage. It lacks details on edge cases (e.g., ambiguous hashes) but covers what an agent needs to invoke correctly. The absence of an output schema is compensated by the description's output explanation.

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

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

Schema description coverage is 100%, with both parameters (hash_str and hashfile) already described in the schema. The description does not add additional parameter-specific guidance (e.g., when to use one over the other). It only indirectly references the hash string. Baseline 3 is appropriate since the schema already documents 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 states a specific verb (identifies), a resource (hash string), and the output (list of possible algorithms). It explicitly names common algorithms (MD5, SHA1, etc.) and clearly distinguishes itself from cracking tools like john and hashcat by stating it should be used BEFORE 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 gives explicit usage context: 'Use BEFORE attempting to crack a hash' and explains why (to select correct mode in hashcat or format in john). This clearly routes the agent to use this tool before cracking tools, distinguishing it from the sibling cracking 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?

No annotations are provided, so the description carries the full burden. It states it is a 'fast brute-force tool', implying many login attempts, and discloses the output format. However, it does not mention potential side effects such as account lockouts, network load, or the need for authorization. These are relevant for a brute-force tool and would improve transparency, so a 3 is appropriate.

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

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

The description is three sentences long, with the primary purpose stated first, followed by usage instructions and a clear alternative. Every sentence contributes value—there is no fluff or repetition. The structure is clean and front-loaded, making it easy for an agent to quickly understand the tool.

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

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

The description covers purpose, usage, alternatives, and output format, which are the essentials for an agent to call it correctly. It does not explain service-specific options (e.g., how to construct http-post-form parameters), but the schema provides examples. Given the tool's complexity and the absence of an output schema, the description is fairly complete, but a mention of potential error conditions or timeouts would push it to a 5.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds only a general statement about providing user/password lists and target service, which is already covered by the schema. It doesn't add syntax examples or clarify the 'opts' parameter beyond what the schema provides. Since the schema already documents the parameters, the description's contribution is minimal, meeting the baseline of 3.

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

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

The description clearly states it is a network login brute-force tool supporting 50+ protocols, names specific protocols, and explicitly distinguishes it from offline hash cracking tools (john, hashcat). The verb 'brute-force' and resource 'network services' are specific, and it mentions the output format, leaving no ambiguity about what the tool does.

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 explicit usage guidance: 'Use for testing password strength on network services' and provides the key steps ('Specify the target service and provide user/password lists'). It also names an alternative ('For offline hash cracking, use john or hashcat instead') which clarifies when not to use it. However, it doesn't mention when to prefer other network scanning tools (e.g., nmap) or exclusion conditions, so it is slightly 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 does mention that output varies by module and includes remote command execution and shell access, but it omits important operational traits such as potential for service creation, need for admin privileges, and risk of detection or impact on the target.

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

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

The description is concise and front-loaded with the tool's identity and examples, followed by a useful output note. It avoids filler, though it could be slightly more structured with explicit headings without harming conciseness.

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

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

For a multi-module tool with no output schema and no annotations, the description covers the breadth of functionality and output variability, but it lacks per-module option construction, prerequisites, or caveats. It is adequate for basic selection but incomplete for reliably invoking all modules 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 already documents all parameters, but the description adds meaningful semantics by explaining what each listed module does (e.g., 'secretsdump (dump credentials remotely)'). This helps an agent choose a valid module name, going beyond the generic 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 identifies Impacket as a collection of Python tools for Windows/AD post-exploitation and enumerates several modules with their functions. This is specific enough to distinguish it from the sibling scanning and exploitation tools, though it does not explicitly name alternatives.

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

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

The phrase 'Use for post-exploitation Windows/AD operations when you have credentials' sets a clear usage context and prerequisite. It does not name sibling tools to avoid or provide when-not-to-use conditions, but the context is sufficient for an agent to select it appropriately.

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 that john is offline, CPU-based, supports auto-detection, and states the output format. It does not mention resource consumption or runtime expectations, but for a cracking tool the key operational 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 compact and front-loaded: identity, purpose, use cases, alternative, and output appear in a logical order with no filler. Every sentence contributes either selection guidance or invocation context.

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

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

For a tool with no annotations and no output schema, this description covers purpose, when to use it, when not to use it, operational constraints, and output. Minor gaps like runtime expectations or the exact behavior of auto-detection remain, but the essential information for correct selection and invocation is present.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds context about hash sources and output, but it does not add substantive parameter-level meaning beyond what fmt/wordlist/opts descriptions already provide.

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

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

The description states a specific verb and resource: 'offline password hash cracker.' It names concrete sources (/etc/shadow, SAM, captured network hashes), lists hash format support, and explicitly contrasts itself with the sibling tool hashcat, so an agent can distinguish it without reading schemas.

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

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

The description gives explicit when-to-use guidance: cracking offline hashes from shadow/SAM/network sources, and CPU-based cracking for smaller sets. It also names the alternative, hashcat, for GPU-accelerated large sets. This is clear routing among siblings.

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

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

With no annotations provided, the description carries the full burden. It discloses the output format (table of names, ranks, descriptions) but does not mention potential side effects, permissions, or any operational caveats. For a read-only listing tool this is adequate 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 three sentences with no wasted words. It front-loads the primary purpose, explains the use case, and ends with the output format. It is concise and well-structured, though it could be slightly more explicit about default behavior (no filters) for absolute clarity.

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 listing tool with two optional filters and no output schema, the description covers the essential elements: what it lists, why to use it, how to filter, and what the output looks like. It is complete enough for an agent to call correctly, though it omits details about rank definitions or the full list of platforms/architectures supported beyond the given examples.

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

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

The schema description coverage is 100%, so both arch and platform are already documented. The description reinforces filtering by these fields but adds no new semantic detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the resource 'all available msfvenom encoders' with their ranks and descriptions. It distinguishes itself from related sibling tools like list_payloads by specifying 'encoders', though it does not explicitly name any alternative.

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

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

It provides a clear use case: 'Use to find the best encoder for your target architecture' and explains how to filter by platform or architecture. It does not mention when not to use this tool or alternatives, but the guidance is sufficiently clear 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?

No annotations are provided, so the description carries the full burden. It states that the output is a list of supported encryption methods, which is minimal. It does not disclose whether it requires msfvenom to be installed, whether it might return an empty list, or any side effects (though a list operation is inherently read-only). The behavior is adequately described for a simple listing tool, but lacks nuance.

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

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

The description is two sentences with no redundancy. The primary action and resource are front-loaded, and the output is briefly stated. Every word earns its place.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description is sufficiently complete. It tells what it lists, gives examples, and states the output format. A minor gap is the lack of clarification on the difference between encryption and encoding, and whether this list is exclusive to msfvenom or includes other methods, but this does not hinder the agent's ability to call 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?

There are zero parameters and none are required. According to the rubric, the baseline for 0 parameters is 4. The description adds no parameter-specific meaning because there are none to explain, and the schema is empty. This is appropriate.

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

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

The description clearly states the action ('List available msfvenom encryption/encoding formats') with specific examples (aes256, rc4, xor, base64). It distinguishes itself from siblings by focusing on encryption, though the inclusion of 'encoding' might cause overlap with the sibling 'list_encoders'. Overall, the purpose is clear and specific.

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 context: 'Use to see what encryption options are available for payload generation.' This gives a reason to use the tool but does not explicitly mention when not to use it or how it differs from alternatives like 'list_encoders'. Usage guidance is present but not fully 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, the description carries the behavioral disclosure. It states the output format ('table of payload names with descriptions, organized by platform') and the filtering capability. It does not explicitly mention that it's read-only, but the verb 'list' strongly implies it, and the output description clarifies the result. It could add caveats about large result sets, but that's minor.

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

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

The description is two sentences plus a one-sentence output note. It front-loads the core action, provides usage timing, lists filters, and describes the output—no filler. Very efficient.

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

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

For a simple listing tool with no output schema and no annotations, the description covers the essential context: what it does, when to use it, how to filter, and what the response looks like. It could mention pagination or size, but given the tool's simplicity, it's 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?

The input schema already describes each parameter with 100% coverage. The description adds examples of filter values and connects them to use cases ('target platform and connection type'), but it lists only subsets of allowed values and does not elaborate on format or constraints beyond the schema. Value is marginal.

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

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

The description states a specific verb 'List' with a clear resource 'all available msfvenom payloads with descriptions,' and positions it as a pre-generation step, distinguishing it from related tools like msfvenom, list_encoders, and list_encryption. The purpose is unambiguous.

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

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

It explicitly tells the agent when to use the tool: 'Use BEFORE generating a payload to find the correct payload name for your target platform and connection type.' It also explains filtering options with examples, though it doesn't explicitly name alternative tools for when not to use it. The context is clear enough.

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 behavioral burden. It discloses key traits: asynchronous, ultra-fast, lacks service/version detection, and outputs a list of open ports with optional banner grab. However, it omits operational caveats like needing privileged/raw-socket access or the network-disruption potential of high scan rates, so it's not fully 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?

Five short sentences, each serving a purpose: definition, usage context, comparison, workflow, and output. Front-loaded with the core scanner identity and no filler. This is efficiently structured and easy to parse.

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

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

The description covers purpose, when to use, key limitations, and expected output, fitting the 3-parameter schema well. Minor gaps – such as root privileges, runtime implications, or raw-packet side effects – keep it just short of fully complete for a network 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 100%, so baseline is 3. The description only indirectly references ports and rate via workflow and output, adding no new parameter-level meaning beyond the schema. It does not lift above the baseline.

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

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

States a specific verb and resource: an ultra-fast asynchronous TCP port scanner for large IP ranges. Explicitly contrasts with nmap for bulk scanning, making its identity distinct among siblings. The 'scan' + 'TCP ports' combination is unambiguous.

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

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

Explicitly states when to use it ('scan large IP ranges') and provides a typical workflow: masscan to find open ports, then nmap for details. It also tells when masscan is insufficient – no service/version detection – giving clear guidance compared to siblings like nmap.

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 mentions the tool extracts credentials but omits critical behavioral traits: it requires elevated privileges (e.g., admin/seebug), may trigger antivirus or endpoint detection, and could crash the LSASS process if used carelessly. For a well-known post-exploitation tool, this is a significant gap. The example in the schema hints at privilege escalation, but the description itself does not disclose these risks.

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

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

The description is compact and front-loaded: two sentences that immediately convey the tool's role, target platform, and output. There is no fluff or repetition, and every sentence adds value.

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 complex with many subcommands, but the schema only exposes one free-form string. The description covers the output format at a high level but omits prerequisites (admin rights, Windows environment), potential side effects, and error handling. An agent might not know that 'privilege::debug' is required or that the tool can be detected. Given the absence of annotations and output schema, more operational detail is needed to ensure correct and safe invocation.

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

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

The schema already provides 100% coverage for the single parameter 'opts', including a concrete example command. The description adds no further meaning beyond confirming the tool's purpose. Since schema coverage is high, a baseline of 3 is appropriate; the description does not need to re-document the parameter, but it also doesn't enrich it.

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

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

The description clearly states the tool's specific purpose: extracting plaintext passwords, NTLM hashes, Kerberos tickets, and PINs from memory (LSASS) on a compromised Windows system. It uses a specific verb (extracting/dumping) and a precise resource, making it easy to distinguish from sibling tools that perform scanning, network, or cracking tasks.

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

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

It gives explicit context on when to use it: 'Use on a compromised Windows system to dump credentials.' While it doesn't list alternatives or exclusions, the context is clear enough for an agent to select it over network-scanning or password-cracking tools. It could be improved by noting that it's specifically for post-exploitation credential access rather than initial reconnaissance.

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 of behavioral disclosure. It only gives the high-level purpose and a generic output note; it does not mention non-interactive execution via the command argument, resource file behavior, side effects, or the destructive potential of running exploit and post-exploitation modules.

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

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

The description is concise and front-loaded with the core purpose, followed by useful sibling disambiguation and an output summary. Minor redundancy exists in 'without the console' versus 'without opening console,' but every sentence earns its place.

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

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

For a powerful and potentially destructive tool, the description covers what the tool does, when to use it, and what output to expect, while the schema covers parameters. Missing context includes the non-interactive execution model and safety expectations, making it adequate but not comprehensive.

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

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

Schema description coverage is 100%, so command, opts, and resource_file are already documented, including the override behavior. The description adds no parameter-level meaning beyond that, which is acceptable at the baseline.

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

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

The description states a specific verb and resource: 'primary interface for running exploit, auxiliary, post-exploitation, and payload modules.' It also explicitly distinguishes sibling tools by directing standalone payload generation to msfvenom and module search to msf_search, so an agent can tell them apart.

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 explicit usage context: 'Use to execute exploits, scan with auxiliary modules, or run post-exploitation tasks.' It names alternatives with their conditions, such as msfvenom for standalone payloads and msf_search for searching modules without opening the console.

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 behavioral burden. It does disclose the managed resource, setup ordering, and output nature, but omits side-effect warnings for destructive commands like 'reinit' and 'delete' that appear in the schema.

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

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

Three sentences: purpose, usage sequence, and output. No filler, information is front-loaded, and every sentence earns its place.

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

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

For a simple two-parameter wrapper, purpose, command ordering, and output are covered, and the schema documents allowed commands and default. The main gaps are the lack of destructive-command warnings and no rationale for choosing this over a sibling, but those are minor for invocaton.

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

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

Schema coverage is 100% for both parameters, so baseline 3 applies. The description adds practical meaning to command values ('init' before first use, 'start' launches, 'status' checks), but leaves 'opts' opaque and mostly repeats schema command 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?

Description states a specific verb ('manages/controls') and resource ('PostgreSQL database used by Metasploit'), and names concrete commands. It is immediately distinguishable from sibling tools like nmap, msfconsole, and msfvenom, none of which manage the Metasploit database.

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

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

Provides explicit usage context: run 'init' before first use, 'start' launches the DB, 'status' checks if running. It doesn't name alternatives or exclusions, but for a self-contained DB lifecycle tool the when-to-use guidance is clear.

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

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

No annotations are provided, so the description must carry the behavioral burden. It does indicate this is a read-only inspection operation by saying 'Display detailed information' and describes the output structure. However, it does not state prerequisites such as whether the module search index must be loaded or whether any state is modified.

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

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

The description is three sentences with no filler. It front-loads the primary action, then gives workflow context, then lists output details. Every sentence contributes useful 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?

For a simple tool with one required parameter and no output schema, the description is complete: it states the action, the expected output, and when to use it in the flow. The schema covers parameter format, and the description covers return value expectations.

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

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

The schema already documents the single parameter module_path with full descriptions and examples, so description-level parameter guidance adds little beyond the schema. The description's mention of 'option table' is relevant output context but does not add more to parameter meaning.

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 ('Display detailed information') and names the exact resource (a specific Metasploit module) and what is included: description, options, required settings, targets, and references. It differentiates itself from the sibling msf_search by being the follow-up inspection step.

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 'Use after msf_search to understand what a module does and what parameters it needs before running it,' which gives clear sequencing and context. It does not explicitly name alternatives or negative cases, but the workflow placement is clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that commands are executed sequentially and that output is combined, which is useful. However, it does not disclose potential side effects (e.g., network activity, destructive actions), error handling behavior (what happens if a command fails), or prerequisites like initialized Metasploit database. This is adequate 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 compact and efficient: two sentences plus an output note. The primary purpose is front-loaded, with use cases and behavior clearly stated. There is no redundant or filler content; every sentence earns its place.

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

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

For a tool with a single parameter and no output schema, the description covers the essential aspects: what it does, when to use it, how the input script works, and the output format. It lacks details on error handling or potential side effects, but given the simplicity and the presence of sibling tools for other needs, it is sufficiently complete for correct invocation.

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

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

Schema coverage is 100% and the parameter script_path has a description ('Path to .rc resource script file'). The tool description adds meaningful context by explaining that resource files contain msfconsole commands (one per line), which goes beyond the schema. This enhances the agent's understanding of the parameter format and expected content.

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 executes Metasploit resource scripts (.rc files) for batch automation, using a specific verb ('Execute') and resource. It distinguishes itself from siblings like msfconsole (interactive) and msfvenom (payload generation) by focusing on pre-written multi-step sequences. The purpose is unambiguous and differentiated.

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

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

The description explicitly lists use cases: running pre-written attack sequences, setting up multi-handlers, and automating complex module chains. It also clarifies that resource files contain msfconsole commands executed sequentially, giving context on how to prepare inputs. However, it does not explicitly state when NOT to use it (e.g., for single commands, use msfconsole), leaving some inference to the agent.

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 for behavior. It discloses the output (module paths, disclosure dates, ranks, descriptions, table) and implies a read-only search operation. It does not state restrictions, failure modes, or whether any setup (e.g., msfdb) is required, but those are not major 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 definition is front-loaded: purpose in the first sentence, usage guidance in the second. It is slightly padded by the redundant final 'Output: table...' sentence that echoes the earlier return-value sentence, but overall it is tight.

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

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

For a two-parameter read-only search tool with no output schema, the description is complete: it states the search surface, when to use it, what is returned, and how to continue with msf_info. There is no important missing context for correct invocation.

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

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

Schema coverage is 100%, so the schema already documents the query and module_type fields well. The description lightly reinforces the search dimensions ('keyword, CVE, platform, or module type') and the module_type filter, but adds little beyond the schema.

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

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

The description names a specific action ('Search the Metasploit module database') and enumerates search dimensions (keyword, CVE, platform, module type). It also fixes the resource and mentions the exact return fields, and the msf_info pointer distinguishes it from 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?

Explicitly instructs when to use it: 'Use BEFORE opening msfconsole to find relevant modules for a target.' It also names the next step and alternative tool, msf_info, so an agent knows the workflow.

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 of behavioral disclosure. It mentions the output ('generated payload in the requested format, or list of available payloads/encoders') but does not disclose any side effects (e.g., file creation, network activity, permissions required, or whether it is safe to run in a sandbox). For a tool that generates executables, this is a notable gap.

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, with two main sentences and a brief output note. It is front-loaded with the purpose and efficiently covers the main use case and alternative. No fluff, though it could be slightly more structured, but it earns a high score for brevity and clarity.

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

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

With 12 parameters and no output schema, the description is thin. It does not explain how parameters interact (e.g., when lhost/lport are needed, what happens if outfile is omitted, or how to trigger the 'list of available payloads/encoders' behavior). The tool is complex, and the description leaves many operational details to inference, making it incomplete for reliable agent use.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only high-level context (e.g., 'reverse shells, meterpreter' as examples of payloads) but does not clarify parameter interplay or provide any semantics beyond what the schema already documents. It does mention that output can be a list of payloads/encoders, which hints at some conditional behavior but not parameter-specific.

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 is a 'Metasploit payload generator' that 'creates shellcode and executables from payloads', specifying the core function. It also distinguishes itself from the sibling 'evasive_payload' by explicitly stating that tool is for AV-evasion with encoding, encryption, and template injection, making its own scope clear.

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

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

The description explicitly says 'Use for generating standalone payloads (reverse shells, meterpreter, etc.) in various formats' and directly routes AV-evasion needs to 'evasive_payload instead'. This gives clear when-to-use and when-not-to-use guidance with a named alternative.

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 does disclose the core behaviors (connect, listen, transfer files, spawn shells) and the connect/listen modes via parameters, but it does not mention potential security implications, privilege requirements, or that it is a raw socket utility that may be flagged by firewalls. For a tool with security-sensitive capabilities, a bit more disclosure would be ideal, but the basics 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?

Two sentences with no wasted words. The core purpose and use cases are front-loaded, and the alternative tool guidance is neatly appended. Perfectly concise and well-structured.

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

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

For a simple utility with full schema coverage and no output schema, the description adequately covers main use cases, modes, and alternatives. It could mention that UDP is supported (though the description says TCP/UDP) or touch on interactive usage, but these are minor. Overall, an agent can correctly invoke it for common tasks without further information.

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

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

Schema description coverage is 100% for all three parameters (host, port, connect), including the default behavior of connect=true. The description adds minimal extra meaning beyond the schema, only implicitly referencing listen vs. connect. This meets the baseline for full schema coverage but does not elevate it.

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

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

The description clearly states it is a TCP/UDP connection utility for connecting, listening, file transfer, and shell spawning. It specifies concrete use cases like service banner grabs and connectivity tests, and explicitly contrasts with nmap for enumeration and tcpdump for packet analysis, making it easy to distinguish from siblings.

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

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

It provides explicit when-to-use guidance (quick banner grabs, port tests, shells) and names alternatives with conditions ('prefer nmap' for structured enumeration, 'tcpdump/tshark' for raw analysis). This is exactly the kind of routing an agent needs.

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

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

With no annotations, the description carries the full disclosure burden. It clearly states the tool does NOT exploit and only reports, and it describes the output as a categorized list with severity. This provides important safety and behavioral context, though it does not mention network impact or permission requirements.

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

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

The description is compact and front-loaded, covering the core purpose, usage timing, alternatives, non-exploit behavior, and output structure in three sentences. Every sentence contributes value without redundancy.

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

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

For a tool with one required parameter and full schema coverage, the description covers what it does, what it finds, when to use it, what it does not do, and the expected output format. Since there is no output schema, the explicit output description fills that gap well.

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

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

Schema coverage is 100%, so the description does not need to compensate for undocumented parameters. It adds little parameter-level detail, but the baseline of 3 applies because the structured schema already handles parameter semantics.

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

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

The description states a specific resource and action: a web server vulnerability scanner that checks for 6700+ known issues across defined categories. It also distinguishes itself from sibling scanners by naming nuclei and wpscan as alternatives for different scopes.

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 explicitly says to use the tool early in web recon for low-hanging vulnerabilities and provides clear routing: nuclei for modern CVE-based scanning and wpscan for WordPress-specific scanning. This gives an agent both when-to-use and when-not-to-use 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 what the tool does (scans hosts/ports/services/OS) and what it returns (open ports, service banners, detected OS), which is useful. However, it does not mention potential side effects like network traffic volume, privileges required (e.g., root for OS detection), or that scanning may be blocked by firewalls. This leaves a gap in behavioral 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?

Five concise sentences, each earning its place: purpose, primary usage, expected output, and two alternative routes. The most critical information is front-loaded, with no filler or repetition.

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

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

The description is complete for a tool with 3 well-documented parameters and no output schema. It explains the tool's scope, output, and alternatives. It could mention reading the opts parameter for advanced use, but the schema already covers that. Given the tool's complexity, this is 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?

Schema description coverage is 100%, and all three parameters (target, opts, ports) have detailed descriptions including examples and defaults. The tool description does not add any extra parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('scanner') and resource ('network'), and enumerates concrete capabilities: host discovery, port scanning, service/version detection, OS fingerprinting. It also differentiates from siblings by naming masscan and arp_scan as alternatives for different use cases, so an agent can immediately distinguish it.

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

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

Explicit guidance is given: 'Use this FIRST on any target to understand what's running.' It also provides when-not-to-use by directing to masscan for fast bulk port scanning and arp_scan for local subnet host discovery. These alternatives and conditions are clear and actionable.

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 burden. It discloses output details (vulnerability name, severity, matched endpoint, remediation reference) and notes template-based scanning with community-maintained YAML templates. However, it does not mention any potential side effects (e.g., active scanning may be intrusive) or failure modes. Since this is a vulnerability scanner, silently omitting that it sends network requests is a moderate gap.

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, starting with the purpose in the first sentence, then elaborating capabilities and usage. Every sentence adds value: purpose, detection types, usage guidance, and output format. No redundant or extraneous content.

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

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

For a tool with two parameters and no output schema, the description is largely complete. It explains what the tool does, when to use it, and what it returns. It lacks specific prerequisites (e.g., network access, target must be reachable) or caution about active scanning, but these are implied. Given the breadth of siblings, the description sufficiently orients the agent.

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

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

Schema description coverage is 100%, so both parameters (target and opts) are already documented in the schema. The description adds no parameter-specific details beyond what the schema provides. It mentions template-based scanning and CVE detection, which aligns with the opts description, but does not introduce new semantics. Baseline 3 is appropriate.

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

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

The description states a specific purpose: 'Modern template-based vulnerability scanner' with a clear resource (targets) and action (scans for CVEs, misconfigurations, exposed panels, etc.). It explicitly contrasts with nikto ('Much faster and more current than nikto'), distinguishing it from that sibling 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 explicit guidance: 'Use as your primary vulnerability scanner after discovering services.' This tells when in the workflow it fits relative to service discovery tools (e.g., nmap) and directly names nikto as an alternative, highlighting why nuclei is preferred. The conditions and comparison are clear.

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

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

With no annotations provided, the description carries the full burden. It discloses that it is fast and outputs a list of IPs with valid community strings and system descriptions. It does not mention potential side effects like network noise, privilege requirements, or whether it is active/passive. While these may be inferred, the description lacks explicit disclosure, making it adequate but not comprehensive.

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

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

The description is two sentences, front-loaded with the core purpose, followed by usage context and output format. Every sentence adds value, with no fluff. The structure guides the agent from what, to when, to what to expect.

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 output (list of IPs with community strings and system descriptions), which compensates for the lack of an output schema. It also provides usage context and speed comparison. It does not mention prerequisites like open UDP port or permission requirements, but these are minor gaps given the tool's nature. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

Schema coverage is 100%, with all three parameters documented in the schema. The description does not add meaning beyond what the schema already provides, except for a vague mention of 'public, private, or custom' community strings, which is not parameter-specific. Per calibration, baseline 3 is appropriate when the schema handles parameter 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 clearly states the tool is a fast SNMP scanner that discovers devices and tests community strings, explicitly distinguishing it from snmpwalk and other network scanners. It specifies the resource (SNMP devices on port 161) and the action (testing community strings), leaving no ambiguity about its function.

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 when-to-use guidance: 'Use when you suspect SNMP is running (port 161 UDP) and want to find readable community strings.' It also notes it is faster than snmpwalk for initial discovery, implying an alternative. However, it does not explicitly state when not to use it or name other alternatives, so a small gap remains.

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 behavioral burden. It discloses the output format ('the wrapped tool's normal output, plus proxy chain connection debug info') and notes that it 'forces' connections through proxies, implying network redirection. It does not mention potential failures (e.g., unreachable proxies) or that it modifies network traffic, but these are minor given the clarity of the core 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 three sentences: the first states purpose and mechanism, the second gives usage guidance, and the third states output. It is front-loaded with the core purpose, includes a concrete example, and contains zero filler. Every sentence earns its place.

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

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

For a two-parameter wrapper with no output schema and no annotations, the description covers the essential aspects: what it does, when to use it, the config file dependency, and the output format. It could mention that it only works on TCP (already implied) or that it may require the proxy chain to be reachable, but the description is sufficiently complete 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?

Schema description coverage is 100%, so the baseline is 3. The description adds a brief example for the 'command' parameter and clarifies that 'opts' can override the config, but these are largely redundant with the schema's own parameter descriptions. The description does not add substantial new semantic meaning beyond what the schema already provides.

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

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

The description opens with 'Proxy wrapper — forces any TCP-based tool's connections through a chain of proxies', which is a specific verb+resource that clearly distinguishes it from the sibling tools (nmap, curl, etc.) – it is a wrapper, not a standalone scanner. It also states the config source and provides a concrete example ('proxychains nmap -sT target.com'), leaving no ambiguity about what the tool does.

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 explicit use cases: 'route tools through a pivot host (after setting up chisel or SSH tunneling) or through Tor for anonymity.' It also implies when not to use it (only for TCP-based tools) and mentions the prerequisite of setting up a pivot host. It does not explicitly name alternatives, but the context is clear enough that an agent can 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'brute-force attack' and output progress, which conveys the aggressive, long-running nature. However, it omits potential side effects like AP lockout or detection risk, and does not mention prerequisites like monitor mode (though the schema implies it). The description is honest 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 concise, front-loading the core purpose and usage, then providing the alternative. The output note is appended. It is well-structured with no redundancy, earning a 4 for efficiency.

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

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

Given the tool's complexity and lack of annotations or output schema, the description covers purpose, usage, and output. It lacks caveats about the attack being time-consuming, potentially triggering AP lockouts, or needing physical proximity. These omissions could affect an agent's expectation of runtime or side effects, making the description adequate but not fully 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 100%, so the schema already documents all parameters (interface, bssid, channel, opts). The description adds no extra semantics beyond the schema, such as option syntax or expected formats, so a baseline score of 3 is appropriate.

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

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

The description clearly identifies the tool as a WPS brute-force attack tool that exploits the WPS PIN vulnerability to recover WPA/WPA2 passphrases. It distinguishes itself from wifite by specifying that wifite handles full WiFi attack automation including handshake capture, making the purpose and differentiation 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 explicitly states when to use the tool ('when the target AP has WPS enabled') and provides an explicit alternative for other scenarios ('For full WiFi attack automation including WPA handshake capture, use wifite'). This gives the agent clear routing guidance.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It clearly states the active poisoning behavior, the protocols involved, the credential-capture outcome, and the expected output in terms of hashcat mode 5600. It does not mention privilege requirements, indefinite listener behavior, or potential network side effects, but it is substantially 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 compact and front-loaded with the core purpose before moving to usage and output. There is some redundancy between 'captures NTLMv2 password hashes' and 'Output: captured NTLMv2 hashes,' but every sentence still contributes useful 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?

For a tool with only one required parametera and no output schema or annotations, the description provides enough context to use it: what it does, when to use it, where to run it, and what result to expect. It omits operational details such as needing elevated privileges or how to stop the listener, but the core invocation context is present.

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

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

The schema already provides 100% coverage for both parameters: interface is described as the network interface to listen on and opts includes example flags. The description adds no additional per-parameter detail beyond roughly restating the schema's interface requirement, so the baseline 3 is appropriate.

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

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

The description clearly identifies the tool as an LLMNR, NBT-NS, and mDNS poisoner that responds to name-resolution requests and captures NTLMv2 hashes from Windows systems. This is a specific verb+resource pairing that distinguishes it from sibling tools like hashcat (which cracks hashes) or nmap (which scans networks).

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 explicitly says to use the tool during internal network assessments when systems attempt to resolve nameshol and instructs running it on an interface with an IP on the target subnet. It does not name alternative tools or state when not to use it, so it stops 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?

With no annotations provided, the description carries the full burden. It discloses that commands are parsed into arguments, that dangerous commands (rm, dd, shutdown) are blocked, and that output is stdout/stderr. It doesn't detail what happens on blocked commands (error message? exit code?), but the safety restriction disclosure is valuable and goes 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 compact and front-loaded with the core purpose, then the fallback guidance, then safety restrictions, then output. Every sentence earns its place, though the output sentence is slightly redundant with the schema's absence of output schema.

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

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

For a generic command execution tool with 2 params and no output schema, the description covers purpose, usage, safety, and output. It could mention what happens when a command is blocked or how timeout behaves, but the essentials are present. The sibling list is large, but the fallback positioning handles differentiation.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the example format and the safety restriction context, but doesn't add significant meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool executes arbitrary commands on the Kali system, with a specific verb ('Execute') and resource ('command on the Kali system'). It explicitly distinguishes itself from dedicated tools by positioning itself as a fallback, which differentiates it from the many sibling tools.

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

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

The description explicitly says to use it ONLY as a fallback when a dedicated MCP tool is not available, and instructs to prefer dedicated tools for better validation and structured output. This is clear when-to-use and when-not-to-use guidance with an explicit alternative.

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 output ('exploit title, path, and sometimes the exploit file content') and implies a non-destructive search operation. It does not explicitly state that it only searches and does not execute exploits, but the wording is sufficiently 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?

Three dense sentences with no filler. The core purpose is front-loaded, followed by usage guidance and output details. Every sentence contributes useful 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?

For a tool with no output schema and no annotations, the description covers what the tool does, what inputs it accepts, when to use it, what output to expect, and how it relates to a sibling tool. Nothing essential for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by explaining valid query forms (software name, version, CVE, description) and how to position the query in a workflow ('after identifying software versions'). The opts parameter is well documented in the schema itself.

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

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

The description states a clear verb ('Search'), a specific resource ('the Exploit Database'), and the kinds of inputs accepted ('software name, version, CVE number, or vulnerability description'). This clearly distinguishes it from sibling discovery/exploitation tools, and specifically contrasts it with msf_search.

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

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

Explicitly says when to use it ('Use after identifying software versions from nmap, whatweb, etc.') and names an alternative ('Pair with msf_search for Metasploit module equivalents'). This gives an agent actionable decision criteria.

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 clearly discloses the main behavior—converting raw shellcode into a Windows executable and returning its path—but it does not clarify whether the tool executes the shellcode, how it handles an existing output file, or any side effects beyond generating a file. This leaves some behavioral ambiguity for an agent.

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 appropriately short and front-loaded: it states the core conversion in the first sentence, gives usage context in the second, and explicitly lists the output in the final phrase. Every sentence earns its place 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 file-conversion tool, the description provides the necessary context: what it converts, when to use it, and what it returns. It compensates for the lack of an output schema by explicitly reporting the output path. Minor gaps include not mentioning prerequisites or failure behavior, but these are not critical for an agent choosing and invoking 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?

All three parameters are already documented in the input schema with 100% coverage, so the baseline is 3. The description adds little parameter-specific meaning beyond indicating the shellcode comes from a file and that the output is a path to a generated executable; the schema already covers arch defaults and output path behavior.

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 states a specific verb and resource: 'Convert raw shellcode from a file into a Windows executable.' This clearly identifies what the tool does and differentiates it from sibling payload-generation tools like msfvenom or evasive_payload, since the shellcode is expected to come from an external source.

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 explicit guidance: 'Use when you have shellcode from another source... and need to package it as an EXE for execution.' This provides solid when-to-use context and implies that this tool is not for generating shellcode, though it does not explicitly name alternatives 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?

Description discloses output types and anonymous/null-session usage, but no annotations exist so it must carry the full burden. It does not explain uploads' side effects, permissions, or interactive/error behavior, leaving clear gaps.

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

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

Four sentences each serve a distinct role: purpose, usage, alternatives, and output. Purpose is front-loaded; there is slight overlap between 'connects' and 'Use to access' but no wasted content.

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

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

With no output schema, the description still names expected output forms. Combined with full schema coverage, it is sufficient for an agent to invoke correctly; optional behavioral depth is the only notable omission.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions anonymous/null session and output types, but those are largely restatements of schema fields and add no new syntax or 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?

First sentence names a specific verb ('connects') and resource ('Windows file shares'), with browsing/downloading/uploading. It also contrasts with nmap/crackmapexec and enum4linux, so it is distinguishable from siblings.

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

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

Explicitly states when to use ('Use to access SMB shares...') and when not ('For SMB vulnerability scanning, use nmap or crackmapexec. For automated share enumeration, use enum4linux.'). No inference required.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool is automated, handles detection/fingerprinting/dumping/shell access, and runs non-interactively by default (via opts default). However, it doesn't disclose potential side effects like network traffic, time delays, or the fact that exploitation can be intrusive/destructive. A 3 is fair: it adds useful behavioral context but omits risk-related 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 compact and front-loaded: it states the core function first, then usage context, then output, then alternatives. Every sentence earns its place; no filler or repetition.

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

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

For a tool with 2 params, 100% schema coverage, and no output schema, the description covers the main gaps: what it does, when to use it, what output to expect, and how it differs from siblings. It doesn't mention risk/intrusiveness, which is a minor gap for an exploitation tool, but overall it's complete enough for an agent to select and invoke it correctly.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds context about the default opts ('--batch --random-agent') and the output, but doesn't add much beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Automated SQL injection detection, exploitation, and data extraction') and names the resource (URL parameters). It also distinguishes itself from siblings by naming commix and xsser as alternatives for other vulnerability classes. This is a clear, specific purpose statement that an agent can act on.

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 'Use when you find a URL parameter that may be injectable' and provides exclusions: 'For command injection (not SQL), use commix. For XSS, use xsser.' This is exactly the kind of when-to-use and when-not-to-use guidance that helps an agent select the right tool.

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

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

With no annotations, the description carries the behavioral disclosure burden. It mentions passphrase-protected embedding and the expected output ('embedded file confirmation or extracted hidden content'), which is genuinely useful. It does not disclose whether operations modify the cover file, what happens on wrong passphrases, or whether extraction requires matching the embedding passphrase, leaving some behavioral ambiguity for a security 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 front-loaded: the first phrase immediately identifies the tool as a steganography tool and its supported formats. The use-case sentence and output note are both informative and non-redundant. It is slightly longer than strictly necessary but every sentence earns its place.

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

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

The tool has three operation modes (info, embed, extract) and multiple interdependent parameters, but the description does not explain how to combine parameters per mode or what the 'info' output looks like. The input schema fills in parameter roles, so this is not severely incomplete, but for a tool without an output schema and no annotations, more operational context would be expected.

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

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

The input schema already documents all six parameters with 100% coverage, so the baseline is 3. The description adds useful format context (JPEG, BMP, WAV, AU) and passphrase usage, but it does not explain the relationships between command, cover_file, embed_file, stego_file, and passphrase beyond what the schema already states. This is adequate but not additive.

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

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

The description states a clear verb+resource: it hides data within JPEG/BMP/WAV/AU files and extracts hidden data from them. It also names the primary use cases (CTF detection, data concealment), so an agent can identify the tool's job. It does not explicitly differentiate it from steganography-adjacent siblings like exiftool or binwalk, but the core purpose is unambiguous.

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

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

The description gives useful usage context—'Use to detect hidden messages in files (CTF challenges) or to conceal data'—which implies when to reach for the tool. However, it does not contrast it with alternatives such as exiftool for metadata or binwalk for file carving, nor does it state when not to use steghide. The guidance is present but implicit and incomplete.

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: it discloses passivity, lack of direct DNS queries, and undetectability. It could add more operational details such as runtime or rate limits, but it adequately communicates the key behavioral profile.

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

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

The description is well-structured and front-loaded, but there is slight redundancy in emphasizing passivity both as 'Passive' and 'No direct DNS queries — completely passive and undetectable'. Overall, each sentence earns its place, though minor tightening is possible.

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 schema covers all parameters, the description explains the tool's behavior, use case, output, and key alternatives. No critical info is missing for an agent to invoke subfinder 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 already provides 100% coverage of both parameters, including the example and the warning not to include subdomains. The description does not add significant new parameter-level meaning, but the schema is sufficient, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('passive subdomain discovery'), the resource (target domain), and the method (multiple online sources). It also differentiates itself from sibling tools like dnsrecon and amass, making its 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?

Explicitly says when to use the tool: initial domain reconnaissance to map external attack surface. It also names specific alternatives for related but different tasks: dnsrecon for active DNS brute-force/zone transfers and amass for deeper OSINT.

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 that the tool requires root/privileged access, that it captures in real-time, and that output is raw packet headers (IP, TCP/UDP, payload snippets). It does not mention that capture stops after 'count' packets or that it may be resource-intensive, but the core behavioral traits are disclosed.

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

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

Three sentences with zero waste. The primary purpose is front-loaded, the alternative is named, and the output format and privilege requirement are stated compactly. Every sentence earns its place.

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

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

For a 3-parameter tool with 100% schema coverage and no output schema, the description covers the essential context: purpose, usage, output format, and privilege requirement. It could mention that capture is continuous until count is reached or interrupted, but the schema's count parameter already implies this. The description is complete enough 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?

Schema description coverage is 100%, so the schema already documents all three parameters (filt, count, interface) with examples. The description adds the output format context but does not add meaning beyond the schema for the parameters themselves. Baseline 3 is appropriate.

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

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

The description states a specific verb ('capture'), a specific resource ('packets on a network interface'), and explicitly names the sibling tool it is not ('For deeper protocol analysis and display filtering, use tshark'). This clearly distinguishes tcpdump from tshark and other network tools in the sibling list.

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 states when to use this tool ('live traffic monitoring, debugging connectivity, or capturing evidence of network activity') and names the alternative (tshark) for deeper analysis. It also notes the root/privileged access requirement, which is a key usage condition.

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 of behavioral disclosure. It states that harvesting happens from public sources and that output is organized by source, giving some indication of return structure. However, it does not disclose that the tool makes live network requests, may encounter rate limits, or that certain sources require API keys, which an agent would benefit from knowing before invocation.

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

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

The description is three sentences, each contributing essential information: function and scope, usage context, and output format. It is front-loaded with the most identifying information and contains no filler or repetition.

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

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

For a 4-parameter OSINT tool with no output schema, the description covers the core requirements: what it does, when to use it, and what it returns. It omits practical caveats like API-key requirements or rate-limiting behavior, but those are partially hinted at in the `limit` parameter schema. Overall it is sufficiently complete for an agent to invoke it correctly in a typical early-reconnaissance workflow.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds only a loose contextual link to the `domain` parameter by referencing 'related domains' and 'employee email patterns', but it does not elaborate on `limit`, `source`, or `opts`. This is marginal added meaning above the schema, no penalty is warranted.

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 ('harvesting') and lists the resource types (emails, names, subdomains, IPs, URLs), names example sources, and identifies the tool as multi-source OSINT. This clearly distinguishes it from sibling tools like subfinder or amass that focus on subdomains only, and from nmap which scans live hosts.

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 tells the agent to use it for 'early reconnaissance' and states the intended goals: 'identify employee email patterns, exposed services, and related domains.' It does not explicitly compare against alternatives or give exclusion criteria, but the context is clear enough to route an agent to this tool for passive intelligence gathering.

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 supplied, the description carries the full disclosure burden. It does add useful behavioral context: it can read pcap files or capture live, and it outputs 'detailed packet summaries with protocol-specific fields.' However, it does not mention operational traits such as requiring root/privileges for live capture, the blocking nature of captures until count is reached, or potential high-volume output — gaps that matter for a network-capture 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 three sentences with no waste: definition, use cases/comparison, capability, and output format are all covered. The most identifying content ('Command-line Wireshark', live vs file capture) is front-loaded, and every sentence contributes value.

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 5 fully documented parameters, no annotations, and no output schema, the description covers the core needs: what it does, when to use it, how it compares to a sibling, input modes, and output shape. It falls slightly short by not mentioning operational caveats like privilege requirements or capture termination behavior, but the combination of description and schema is otherwise reasonably 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 100%, so the baseline is 3 even without extra parameter detail. The description mentions 'extracting specific protocol fields' and 'display filters', which loosely ties to opts/filt, but it does not add meaning beyond what the parameter descriptions already provide. It neither hurts nor significantly enhances parameter understanding.

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

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

The description states a specific verb and resource — 'captures and deeply analyzes network traffic with full protocol dissection' — and frames the tool as 'Command-line Wireshark', which immediately signals its identity. It also distinguishes itself from a sibling ('Superior to tcpdump for protocol decoding and display filters'), so an agent can separate it from tcpdump without opening either schema.

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

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

The description explicitly lists when to use the tool: 'Use for detailed traffic analysis, extracting specific protocol fields, or analyzing pcap files.' It also names the primary alternative (tcpdump) and states the advantage, giving clear routing guidance. This is not merely implied; it is direct and actionable.

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 the requirement for a profile and the structured output format, which is useful. However, it does not explicitly state that the tool is read-only (non-destructive) or mention potential operational requirements like elevated privileges or performance implications. These gaps leave the agent with incomplete safety information.

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

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

The description is three sentences with no fluff. It front-loads the core purpose, states the key requirement, and summarizes the output format. Every sentence earns its place, making it easy to scan and digest for an 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 4 parameters, no output schema, and no annotations, the description covers the essential aspects: what it does, the profile requirement, and the nature of outputs. It lacks details on operational edge cases (e.g., handling of malformed images, root privileges), but given the complexity and the read-only nature implied by the tool's purpose, it is reasonably complete for an agent to select and invoke it correctly.

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

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

Schema coverage is 100%, so all parameters are already documented with examples and descriptions. The description adds the note that a profile must match the OS version, reinforcing the 'profile' parameter, and gives example plugins that align with the schema. Since the schema already provides the necessary semantics, the description adds only marginal value, meriting the baseline score of 3.

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

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

The description clearly states it is a memory forensics framework for analyzing RAM dumps, explicitly listing what it extracts (running processes, network connections, DLLs, etc.). This distinguishes it from sibling tools that are network scanners, exploit frameworks, or password crackers, so an agent can immediately identify it as the memory-analysis 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?

The description notes that a matching memory profile is required, which is a key usage prerequisite. While it doesn't explicitly say when not to use it or name alternatives, the unique domain (memory forensics) among siblings makes the use case obvious. It could be improved by stating it's for offline analysis of memory dumps, but the context is strong.

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 must disclose behavioral traits on its own. It does state that output includes 'requests with their response codes, line/word/char counts' and mentions 'auth handling' as a capability. However, it does not disclose potential side effects like network load, rate behavior, or prerequisites (e.g., network access, target reachability). It lacks depth about how the tool behaves during fuzzing, making it only partially 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 concise—three sentences—and front-loaded with a clear purpose ('Feature-rich web application brute-forcer'). It efficiently packs usage scenarios, a comparison to a sibling, and output format without wasted words. Every sentence contributes meaningful 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?

For a network fuzzing tool with 100% schema coverage and no output schema, the description covers the main functional scope, usage cases, a key differentiator, and the output format. It lacks some practical context like typical command-line examples (though schema provides some) or guidance on handling authentication failures, but it is sufficiently complete for an agent to invoke the tool correctly in most scenarios.

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

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

Schema description coverage is 100%, so each parameter already has a clear description (e.g., target includes an example with FUZZ keyword, opts includes an example command). The tool description itself adds no additional meaning about parameters; it only reinforces the tool's general purpose. Thus it stays at the baseline of 3 without adding extra value.

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

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

The description clearly states the tool is a 'web application brute-forcer' that 'fuzzes URLs, POST data, headers, cookies, and authentication'. It identifies specific use cases (parameter discovery, login brute-force, etc.) and explicitly differentiates from sibling ffuf by claiming 'more flexible than ffuf for complex fuzzing'. This gives an agent a precise understanding of what the tool does and how it differs from alternatives.

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

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

The description lists concrete application scenarios ('parameter discovery, login brute-force, header injection testing, and custom fuzzing scenarios') and provides a direct comparison to ffuf ('More flexible than ffuf for complex fuzzing'). However, it does not mention any exclusions or when NOT to use wfuzz (e.g., for simple directory brute-forcing where gobuster/dirb might be better), so it falls short of a full when/when-not distinction.

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 disclose behavioral traits. It calls the tool 'Passive' but does not explain what that means (e.g., no network activity vs. non-intrusive). It also fails to mention that the tool sends HTTP requests, may require network access, or could be rate-limited. The output format is described, but the operational behavior and potential side effects are omitted.

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

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

The description is two sentences, front-loaded with purpose and usage directive. Every sentence earns its place, with no filler. The key guidance ('Use FIRST') is prominent and the output format is stated succinctly.

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 tool with two parameters and no output schema, the description covers the output structure (structured list with versions) and usage context. It lacks details on potential limitations (e.g., misses obfuscated technologies) and does not mention runtime behavior, but these are minor given the tool's simplicity and the strong usage directive.

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

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

The schema already documents both parameters with 100% coverage, so the description adds little beyond what's in the schema. It repeats the aggressive-level example for opts, but does not clarify syntax or edge cases. Baseline 3 applies because the schema carries the load.

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: passive web technology fingerprinting, and lists specific categories it identifies (CMS, frameworks, libraries, etc.). It also explicitly differentiates from sibling tools by instructing to use it FIRST before specialized tools, making its role unambiguous.

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

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

The description provides explicit guidance to use it first on any web target before specialized tools, implying it's a reconnaissance tool. It does not explicitly state when NOT to use it or name specific alternative tools, but the context is clear enough for an agent to decide. The instruction to run it first is a strong usage signal.

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

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

No annotations are provided, so the description must disclose behavior. It mentions automation, minimal user interaction, real-time progress output, and recovered passwords. It also notes that --kill disables interfering services by default, which is a notable side effect. However, it could detail other side effects like network disruption or legal warnings, but the current disclosure 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 compact, front-loaded with the core purpose, and every sentence adds value. It covers what, when, alternatives, and output without 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?

The tool is complex with many sub-steps, but the description summarizes the workflow well. It does not cover legal/ethical warnings or detailed operational steps, but it does provide the key usage context. Given the lack of annotations and no output schema, it could be more complete, but the description is sufficient for an agent to decide to 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 coverage is 100%, so the schema already documents the opts parameter. The description adds the default value and its effect (--kill disables interfering services), which goes beyond the schema. It doesn't explain other possible opts, but given the single parameter, this is reasonable.

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 is an automated wireless attack tool covering the full WiFi cracking workflow, distinguishing it from manual tools like aircrack_ng and reaver. The purpose is specific and understandable, though it could mention the target device (WiFi networks) more explicitly.

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

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

The description gives clear when-to-use guidance: use as primary for streamlined WiFi testing, use aircrack_ng for manual control, and reaver for WPS-specific. It does not explicitly state when not to use it, but the alternatives provide good 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 carries the full burden and does well: it discloses that the tool enumerates components and checks CVEs, and even specifies the output structure (version, vulnerable plugins/themes, usernames). It doesn't mention potential network side effects like WAF alerts, but the read-only scanning nature is strongly implied by 'scanner'.

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

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

Three concise sentences: what it does, when to use it, and what output to expect. Every sentence earns its place and the critical usage caveat is front-loaded in the second 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?

For a network scanner with no output schema, the description covers the essential decision criteria: purpose, usage prerequisite, and return value. It doesn't explain scan speed or block/rate-limit likelihood, but these are minor given the tool's simple invocation and clearly documented output.

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

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

Schema description coverage is 100%, so the schema already documents both parameters with examples. The tool description adds no extra semantic detail about the parameters beyond what the schema provides; it only reinforces the overall scanning purpose.

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 'Dedicated WordPress security scanner' and enumerates exactly what it does: finds plugins, themes, users, and vulnerabilities. This clearly distinguishes it from sibling tools like nikto or gobuster, which are generic web/enumeration scanners.

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

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

Explicitly states 'Use ONLY when the target is confirmed to be WordPress (verify with whatweb first)' – giving both a strict condition and the correct sibling tool to use beforehand. This leaves no ambiguity about when to select wpscan over alternatives.

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

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

With no annotations, the description carries the full behavioral burden and does disclose two useful traits: automatic payload encoding ('Automatically encodes payloads to bypass filters') and output shape ('identified XSS vectors with payload and injection point'). However, it is an 'exploitation framework' yet never discloses operational side effects — that it actively fires payloads at the target, request volume/noise, or authorization expectations — so an agent cannot gauge the impact of invocation.

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

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

Four sentences, roughly 75 words, logically ordered: purpose first, then trigger condition, key behavior, sibling routing, and output. Every sentence earns its place and the most decision-critical info (what it is, when to use it) is front-loaded.

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

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

For a two-parameter tool with no output schema, the description covers purpose, trigger, behavior, alternatives, and return format — most of what an agent needs to invoke it. The gap is risk context: an 'exploitation framework' with no annotations should flag that it actively sends attack payloads and is for authorized targets only. That omission is meaningful for offensive tooling.

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

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

Schema description coverage is 100%, so both parameters are already documented, including a concrete URL example ('http://example.com/search?q=test') and the --auto default for opts. The description adds mild context for what the URL will be used for but no parameter-level syntax or format details beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource: 'XSS detection and exploitation framework' and enumerates the exact coverage ('reflected, stored, and DOM-based XSS'). It distinguishes itself from sibling tools by routing other vulnerability classes elsewhere ('For SQL injection, use sqlmap'), so an agent can tell xsser apart from sqlmap, nuclei, and nikto without opening schemas.

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

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

'Use when you find user input reflected in page output' is an explicit, actionable trigger condition. It also names concrete alternatives for adjacent tasks ('For general web vulnerability scanning, use nuclei or nikto. For SQL injection, use sqlmap.'), effectively providing the when/when-not guidance the rubric rewards.

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