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

With no annotations provided, the description carries full burden but only states what the tool does, not how it behaves. It doesn't disclose whether this is a read-only analysis, if it modifies systems, requires specific permissions, has rate limits, or what the output format might be. This leaves critical behavioral traits undefined for a tool in a security testing context.

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

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

The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for the tool's complexity and front-loads the core functionality without unnecessary elaboration.

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

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

For a tool with 3 parameters, no annotations, and no output schema in a complex penetration testing domain, the description is inadequate. It doesn't explain what constitutes a 'strategy', what format it returns, how it adapts, or any behavioral constraints. Given the rich sibling toolset and security context, more completeness is needed.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description mentions 'detected services and OS' which loosely maps to 'ports' and 'technologies', but adds no meaningful semantic context beyond what the schema provides. The baseline of 3 is appropriate given the comprehensive schema coverage.

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

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

The description clearly states the action ('generate') and the resource ('adaptive penetration testing strategy'), specifying it's based on detected services and OS. It distinguishes from siblings like 'suggest_next_steps' by focusing on strategy generation rather than general recommendations, but doesn't explicitly differentiate from all tools.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'suggest_next_steps' or 'generate_report'. It mentions the input basis but offers no context about prerequisites, timing, or exclusions relative to other penetration testing tools in the sibling list.

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 burden. It mentions 'comprehensive automated' but doesn't disclose critical behavioral traits: whether this is destructive, requires special permissions, has rate limits, runtime duration, or what 'automated' entails (e.g., automatic exploitation). This is a significant gap for a security testing 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 a single, efficient sentence that gets straight to the point with no wasted words. However, it's arguably too concise given the tool's complexity and lack of annotations, potentially under-specifying rather than being optimally concise.

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 likely complexity (automated penetration testing), no annotations, no output schema, and many sibling alternatives, the description is incomplete. It doesn't cover behavioral risks, output expectations, or differentiation from other tools, leaving significant gaps for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (target, scope, intensity). The description adds no additional meaning about parameters beyond what's in the schema, such as examples or implications of choices. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description states the tool performs 'comprehensive automated penetration test', which is a clear verb+action but remains vague about what 'comprehensive' entails. It doesn't distinguish from siblings like 'nmap_scan' or 'nikto_scan' which are more specific penetration testing tools, though it implies broader scope than those.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools for specific tests (e.g., 'nmap_scan', 'sqlmap_scan'), the description doesn't indicate if this is a high-level wrapper, when it's preferred, or what prerequisites might be needed for automated testing.

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 mentions 'active vulnerability scan', implying it's a read/write operation that interacts with the target, but doesn't specify details like potential impact (e.g., intrusive testing, rate limits, authentication needs, or what 'active' entails beyond scanning). This leaves significant gaps for an agent to understand the tool's 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 a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded with the key action and tool, making it easy to parse quickly. Every part of the sentence contributes essential information, earning 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 the complexity of an active vulnerability scanning tool with no annotations and no output schema, the description is insufficient. It doesn't cover behavioral aspects like what the scan does, potential risks, output format, or how it differs from other scanning tools. For a tool that likely involves intrusive testing, more context is needed to ensure safe and effective use by an 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?

The schema description coverage is 100%, so the input schema already fully documents the 'target' and 'scope' parameters. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain parameter formats, constraints, or examples). This meets the baseline score of 3, as the schema handles the parameter documentation adequately.

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 ('Perform active vulnerability scan') and the tool used ('using Burp Suite'), which is specific and unambiguous. However, it doesn't distinguish this tool from sibling tools like 'burp_proxy_scan' or 'nikto_scan', which might also perform vulnerability scanning, so it doesn't fully differentiate 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 provides no guidance on when to use this tool versus alternatives like 'burp_proxy_scan', 'nmap_scan', or other scanning tools in the sibling list. It lacks context about prerequisites, such as needing Burp Suite running or specific target types, and doesn't mention exclusions or complementary tools.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits like whether this is a read-only operation, what happens if no scan results exist, file system implications of 'output_path', or potential side effects. The description is minimal and lacks necessary context for safe use.

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 at just four words, front-loading the core purpose with zero wasted text. Every word earns its place by specifying the tool's essential function.

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 annotations, no output schema, and a mutation-suggesting tool ('Export'), the description is incomplete. It doesn't explain what gets exported, where from, what the output looks like, or error conditions. For a tool with potential file system impact, this leaves significant gaps for safe agent operation.

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 thoroughly. The description adds no additional meaning about parameters beyond what's in the schema (e.g., explaining format choices or typical output paths). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Export') and resource ('Burp Suite scan results'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'generate_report' or specify what exactly is being exported (e.g., raw data vs. formatted report).

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

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

No guidance is provided on when to use this tool versus alternatives like 'generate_report' or other export-related tools. The description gives no context about prerequisites (e.g., needing existing scan results) or typical workflows.

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 mentions 'passive scan' which suggests non-intrusive monitoring, but fails to detail critical aspects like required permissions, impact on the target, rate limits, or what the scan entails operationally (e.g., traffic analysis vs. vulnerability detection).

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with every word contributing to understanding the core functionality.

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 complexity of security scanning tools, no annotations, and no output schema, the description is insufficient. It lacks details on what the scan does (e.g., types of vulnerabilities detected), output format, error handling, or integration with other tools like 'burp_export' or 'generate_report'.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters (target URL and duration). The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints, meeting the baseline for high coverage.

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

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

The description clearly states the action ('perform passive scan') and the mechanism ('through Burp Suite proxy'), which distinguishes it from active scanning tools. However, it doesn't explicitly differentiate from sibling tools like 'burp_active_scan' or 'burp_spider' beyond the 'passive' qualifier.

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

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

No explicit guidance on when to use this tool versus alternatives like 'burp_active_scan' or 'burp_spider' is provided. The description implies a passive scanning context but lacks details on prerequisites, scenarios, or exclusions for usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'spider/crawl' which implies a potentially resource-intensive or intrusive operation, but fails to detail aspects like required permissions, rate limits, output format, or whether it's destructive. This leaves significant gaps for an agent to understand the tool's 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 extremely concise with a single, direct sentence that front-loads the core functionality. There's no wasted verbiage, making it efficient for quick comprehension by an AI agent.

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

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

Given the complexity implied by a crawling tool in a security testing context, no annotations, no output schema, and incomplete behavioral disclosure, the description is inadequate. It doesn't cover critical aspects like what the tool returns, error conditions, or how it integrates with other Burp Suite tools, leaving the agent with insufficient context.

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

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

The input schema has 100% description coverage, with the 'target' parameter clearly documented. The description adds no additional semantic context beyond what the schema provides, such as URL format examples or crawling depth. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.

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 ('spider/crawl') and target ('using Burp Suite'), providing a specific verb and resource. However, it doesn't explicitly differentiate from sibling tools like 'burp_active_scan' or 'directory_scan', which might also involve crawling or scanning behavior, so it doesn't reach the highest score.

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

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

The description offers no guidance on when to use this tool versus alternatives. With many sibling tools like 'burp_active_scan', 'directory_scan', and 'nmap_scan' that might overlap in web assessment contexts, there's no indication of specific use cases, prerequisites, or exclusions.

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

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

With no annotations provided, the description carries full burden but only states what the tool does without disclosing behavioral traits. It doesn't mention side effects (e.g., starting a process that may consume resources), permissions needed, or error handling, leaving significant gaps for a tool that initiates software.

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

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

The description is a single, clear sentence with zero wasted words, making it highly efficient and front-loaded. It directly communicates the core action without unnecessary elaboration.

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

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

For a tool that starts a complex security application with multiple parameters and no output schema, the description is inadequate. It lacks details on expected outcomes, error conditions, or integration with sibling tools, failing to provide sufficient context for effective 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 schema fully documents all parameters. The description adds no additional meaning about parameters beyond what's in the schema, such as explaining interactions or dependencies between them, meeting the baseline for high coverage.

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

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

The description clearly states the action ('Start') and target ('Burp Suite Professional with API enabled'), making the purpose evident. However, it doesn't distinguish itself from sibling tools like 'burp_stop' beyond the obvious action difference, missing specific scope or context differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives or in what context. The description lacks any mention of prerequisites, typical workflows, or comparisons with related tools like 'burp_active_scan' or 'burp_spider'.

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 states the action ('stop') but doesn't describe what 'stop' entails—whether it gracefully shuts down the instance, terminates processes, affects other tools, or requires specific permissions. For a tool with zero annotation coverage, this lack of behavioral detail is a significant gap, though it doesn't contradict any annotations.

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

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

The description is a single, efficient sentence—'Stop Burp Suite instance'—that is front-loaded with the core action. It wastes no words and is appropriately sized for a simple tool with no parameters. Every part of the sentence earns its place by specifying the verb and target.

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 (simple action with no parameters) and lack of annotations and output schema, the description is incomplete. It doesn't explain what 'stop' means behaviorally, what happens after stopping, or any dependencies (e.g., requires a running instance). For a tool that likely interacts with a security testing suite, more context on effects and prerequisites is needed.

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

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

The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics, and it appropriately avoids mentioning any. This meets the baseline expectation for a parameterless tool, though it doesn't go beyond that.

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

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

The description 'Stop Burp Suite instance' clearly states the action (stop) and target resource (Burp Suite instance), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'burp_start', but the verb 'stop' inherently contrasts with 'start', providing some implicit distinction. The description avoids tautology by not merely restating the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., that a Burp Suite instance must be running), exclusions, or relationships with sibling tools like 'burp_start'. While the action 'stop' implies it should be used after starting an instance, this is not explicitly stated, leaving usage context unclear.

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 states the action ('Discover CVEs') but doesn't describe how it behaves—e.g., whether it queries a database, performs live scanning, returns detailed CVE information, has rate limits, or requires specific permissions. This leaves significant gaps 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 a single, efficient sentence that is front-loaded with the core purpose. There is no wasted text, and it directly communicates the tool's function without unnecessary elaboration.

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

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

Given the complexity of CVE discovery in a security context, no annotations, no output schema, and a simple input schema, the description is incomplete. It doesn't cover behavioral aspects, output format, error handling, or integration with sibling tools, making it inadequate for informed 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?

The description adds minimal meaning beyond the input schema, which has 100% coverage. It implies that 'technologies' should include versions for CVE matching, but doesn't specify format, examples, or constraints. With high schema coverage, the baseline is 3, and the description doesn't significantly enhance 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 clearly states the tool's purpose with a specific verb ('Discover') and resource ('CVEs'), and it specifies the input basis ('based on detected technologies and versions'). However, it doesn't explicitly differentiate from sibling tools like 'tech_detection' or 'exploit_attempt', which might have overlapping security contexts.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing detected technologies from 'tech_detection'), exclusions, or comparisons to siblings like 'nuclei_scan' or 'metasploit_search' that might also involve CVE-related operations.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Bruteforce' implies aggressive enumeration that could trigger security alerts or rate limiting, the description doesn't mention these risks, required permissions, expected output format, or whether this is a passive vs. active scan. It lacks crucial operational context for a security testing 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 at just 6 words with zero wasted language. It's front-loaded with the core purpose and contains no unnecessary elaboration. This is an example of efficient communication where 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 security testing tool with 4 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, what constitutes success/failure, ethical considerations, or operational constraints. Given the complexity and sensitive nature of bruteforce operations, more context is needed for safe and effective 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 all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's already in the structured schema. It doesn't explain relationships between parameters (e.g., how 'use_seclists' interacts with 'wordlist') or provide usage examples.

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 ('Bruteforce') and target ('directories and files on web server'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like 'directory_scan' or 'fuzzing_directories', which likely perform similar reconnaissance functions.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools for web reconnaissance (directory_scan, fuzzing_directories, nikto_scan, etc.), there's no indication of when this specific bruteforce approach is preferred or what distinguishes it from other directory discovery methods.

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 burden for behavioral disclosure. It mentions 'Advanced directory scanning' but doesn't specify whether this is passive reconnaissance or active testing, what permissions or access are needed, potential impact on target systems, or output format. For a security scanning tool with zero annotation coverage, this is a significant 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 a single, efficient phrase that front-loads the core functionality. However, it could be more structured by explicitly stating the purpose before listing tools, but it avoids unnecessary verbosity.

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

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

Given the complexity of a security scanning tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior, output, error handling, and differentiation from siblings, making it inadequate for safe and effective use by an AI 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%, with clear parameter documentation in the schema. The description adds no additional parameter semantics beyond implying tool selection from the listed options, which is already covered by the enum. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description states the tool performs 'Advanced directory scanning' and lists specific tools (dirb/dirsearch/gobuster/feroxbuster), which clarifies the action and implementation method. However, it doesn't differentiate from sibling tools like 'directory_bruteforce' or 'fuzzing_directories', leaving ambiguity about when to choose this over those 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'directory_bruteforce' and 'fuzzing_directories' available, there's no indication of context, prerequisites, or comparative advantages, leaving the agent without usage direction.

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

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

No annotations are provided, so the description carries full burden. 'Attempt exploitation' implies a potentially destructive/mutative operation, but the description doesn't disclose critical behavioral traits: whether this requires specific permissions, what happens on success/failure, if it's reversible, rate limits, or safety considerations. For a tool with 'exploit' in its name and no annotations, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a tool with three parameters and no annotations, though it could be more specific about the exploitation context to improve clarity without sacrificing 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 tool named 'exploit_attempt' with no annotations and no output schema, the description is inadequate. It doesn't explain what 'attempt' means operationally, what constitutes success/failure, what the tool actually does during exploitation, or what the expected outcomes are. Given the potentially destructive nature implied by the name and the lack of structured safety information, the description should provide more behavioral context.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (target, vulnerability, payload) with basic descriptions. The description adds no additional meaning about parameters beyond what's in the schema - it doesn't explain what constitutes a valid vulnerability identifier, payload types available, or target format expectations. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description 'Attempt exploitation using detected vulnerabilities' clearly states the action (attempt exploitation) and the resource (detected vulnerabilities), but it's somewhat vague about what specific exploitation means. It distinguishes from many siblings that focus on scanning, discovery, or testing rather than active exploitation, but doesn't specify what type of exploitation or against what targets beyond the generic 'vulnerabilities'.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'auto_pentest', 'burp_active_scan', 'sqlmap_scan', and various testing tools, there's no indication of when exploitation is preferred over scanning, testing, or automated pentesting approaches. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tools used ('ffuf/wfuzz') but doesn't describe what the tool actually does (e.g., enumerates hidden paths, tests for common files), potential side effects, rate limits, or output format. This leaves significant gaps for an agent to understand the tool's 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with every part contributing essential information.

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

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

Given the complexity of a fuzzing tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior, output, error handling, and differentiation from siblings, making it inadequate for an agent to fully understand how to use this tool effectively.

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 ('target', 'tool', 'extensions') with descriptions and enums. The description adds no additional meaning beyond what's in the schema, such as example usage or parameter interactions, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('fuzz directories and files') and specifies the tools used ('using ffuf/wfuzz'), providing a specific verb and resource. However, it doesn't explicitly differentiate from sibling tools like 'directory_bruteforce' or 'directory_scan', which appear to perform similar functions, so it doesn't reach the highest clarity level.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'directory_bruteforce', 'directory_scan', and 'fuzzing_parameters' available, there's no indication of the specific context, prerequisites, or differences that would help an agent choose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tools used (ffuf/wfuzz) but lacks details on execution behavior, such as rate limits, output format, or potential impacts (e.g., whether it's safe or could cause disruptions). This leaves significant gaps for an agent to understand how the tool operates.

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

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

The description is a single, efficient sentence that directly states the tool's purpose and method without any unnecessary words. It is appropriately sized and front-loaded, making it easy to understand quickly.

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

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

Given the tool's complexity (involving fuzzing with external tools) and the lack of annotations and output schema, the description is insufficient. It doesn't explain what the tool returns, how results are structured, or any behavioral nuances, making it incomplete for effective 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 schema already documents both parameters ('parameters' as an array of objects and 'tool' as an enum). The description adds no additional meaning beyond what's in the schema, such as examples of parameter payloads or tool selection criteria, resulting in 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 the action ('fuzz extracted parameters') and the method ('using ffuf/wfuzz'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'fuzzing_directories' or 'parameter_extraction', which limits the score from a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'fuzzing_directories' for directory fuzzing or 'parameter_extraction' for obtaining parameters. There's no mention of prerequisites, context, or exclusions, leaving usage unclear.

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 'generate' and 'comprehensive', but doesn't clarify whether this is a read-only operation, if it requires specific inputs beyond the schema, what the output entails (e.g., file generation, data return), or any side effects like rate limits or authentication needs. For a tool with no annotations, this leaves significant gaps in understanding its 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 a single, efficient sentence: 'Generate comprehensive penetration test report'. It's front-loaded with the core action and resource, with no wasted words. However, it could be slightly more informative without sacrificing conciseness, such as by hinting at output or usage 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?

Given the complexity of penetration testing and the lack of annotations and output schema, the description is incomplete. It doesn't address what the tool returns (e.g., a file, report data), how it integrates with other tools in the sibling list, or any behavioral nuances. For a tool in a security testing context with no structured output information, this leaves the agent under-informed about its full role and results.

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

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

The schema description coverage is 100%, with clear descriptions for both parameters (target and format with enum). The description adds no additional meaning beyond the schema—it doesn't explain what 'target identifier' entails or provide context for format choices. Since the schema already documents parameters well, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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 the tool's purpose as 'Generate comprehensive penetration test report', which is clear but somewhat vague. It specifies the verb 'generate' and resource 'penetration test report', but lacks specificity about what makes it 'comprehensive' or how it differs from other reporting tools in the sibling list (e.g., burp_export). It's not tautological but doesn't fully distinguish from potential 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 provides no guidance on when to use this tool versus alternatives. With multiple sibling tools like burp_export and suggest_next_steps that might involve reporting, there's no indication of context, prerequisites, or exclusions. The agent must infer usage based on the name alone, which is insufficient for optimal tool 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 full burden for behavioral disclosure. It mentions 'search' but doesn't describe what the search returns (e.g., module names, details, or exploits), whether it's read-only or has side effects, or any constraints like rate limits or authentication needs. This leaves significant gaps in understanding the tool's 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 a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by specifying the action, resource, and basis for search, making it easy to parse quickly.

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

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

Given no annotations, no output schema, and a search tool with potential complexity (e.g., returning exploit modules), the description is incomplete. It doesn't explain what the output looks like, how results are formatted, or any behavioral traits like pagination or error handling. This makes it inadequate 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 schema already documents both parameters ('service' and 'platform') with descriptions. The description adds no additional meaning beyond implying that 'service' is detected, which is redundant with the schema. Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate with extra context.

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 'Search' and resource 'Metasploit modules', specifying the purpose as finding modules based on detected services. It distinguishes from siblings like 'exploit_attempt' or 'cve_discovery' by focusing on module search rather than exploitation or vulnerability discovery. However, it doesn't explicitly differentiate from all siblings (e.g., 'suggest_next_steps' might also involve Metasploit).

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 minimal guidance by implying usage when services are detected, but offers no explicit when-to-use rules, alternatives, or exclusions. For example, it doesn't specify whether to use this before 'exploit_attempt' or how it relates to 'tech_detection'. Without such context, the agent must infer usage from the purpose alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Run Nikto web vulnerability scanner' implies an active scanning operation, it doesn't disclose important behavioral traits like whether this is a passive or active scan, potential impact on target systems, authentication requirements, rate limiting considerations, or what the output format looks like.

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

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

The description is extremely concise at just 5 words, front-loading the essential information with zero wasted words. Every element earns its place, making it easy for an agent to quickly understand the tool's basic function.

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 vulnerability scanning tool with no annotations and no output schema, the description is incomplete. It doesn't explain what kind of results to expect, whether this is a comprehensive scan or targeted test, potential side effects on the target, or how this integrates with the broader penetration testing workflow represented by the sibling tools.

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

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

With 100% schema description coverage, the input schema already documents both parameters (url and port) adequately. The description adds no additional parameter semantics beyond what's in the schema, so the baseline score of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Run') and resource ('Nikto web vulnerability scanner'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from other vulnerability scanning siblings like 'nuclei_scan' or 'test_web_application' beyond naming the specific scanner.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple web testing tools available (burp_active_scan, nuclei_scan, test_web_application), there's no indication of Nikto's specific use cases, strengths, or when it might be preferred over other options.

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 'comprehensive port scan' but doesn't specify what that entails—e.g., whether it's intrusive, time-consuming, requires special permissions, or has rate limits. For a security tool with potential impact, this lack of detail is a significant 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 a single, efficient sentence with zero waste—'Perform comprehensive port scan using Nmap'—front-loading the core action and tool. Every word earns its place, making it highly 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?

Given the complexity of a security scanning tool with no annotations and no output schema, the description is incomplete. It lacks details on behavior, output format, risks, or integration with sibling tools, failing to provide enough context for safe and effective use in this multi-tool environment.

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 ('target' and 'scan_type') with descriptions and enum values. The description adds no additional meaning beyond implying a port scan focus, which aligns with the schema but doesn't enhance parameter understanding, meeting the baseline for high coverage.

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

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

The description clearly states the action ('perform comprehensive port scan') and tool used ('using Nmap'), which is specific and unambiguous. However, it doesn't differentiate this tool from sibling scanning tools like 'nikto_scan' or 'directory_scan' in terms of scope or methodology, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available for scanning (e.g., 'nikto_scan', 'directory_scan', 'subdomain_enum'), there's no indication of whether this is for network-level scans, initial reconnaissance, or specific contexts, leaving the agent without usage direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool runs a vulnerability scanner, implying it performs read-only scanning, but it doesn't disclose critical traits like whether it's passive/active, potential impact on targets, authentication needs, rate limits, or output format. For a security tool with no annotation coverage, this is a significant 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 a single, efficient sentence with zero waste—'Run Nuclei vulnerability scanner'—front-loading the core action and tool name appropriately. It's appropriately sized for the tool's complexity.

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

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

Given the complexity of a vulnerability scanner, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and what to expect from the scan results, making it inadequate for an agent to understand the tool's full implications and use it correctly in a security testing workflow.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (target, templates, severity) with descriptions and an enum for severity. The description adds no additional meaning beyond what the schema provides, such as explaining how templates are selected or what the scan entails. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Run Nuclei vulnerability scanner' clearly states the action (run) and the tool/resource (Nuclei vulnerability scanner). It distinguishes this tool from siblings like nmap_scan or nikto_scan by specifying the particular scanner, but it doesn't explicitly differentiate its purpose from other vulnerability scanners in the list (e.g., burp_active_scan).

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for scanning and testing (e.g., nmap_scan, nikto_scan, burp_active_scan), there's no indication of scenarios where Nuclei is preferred, prerequisites, or exclusions, leaving usage context entirely implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the methods (Katana and manual) but lacks details on permissions, rate limits, output format, or potential side effects (e.g., whether it's read-only or may trigger security alerts). This is inadequate for a tool with potential security implications.

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

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

The description is a single, efficient sentence with no wasted words, clearly front-loading the core purpose. It is appropriately sized for the tool's complexity.

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

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

Given the lack of annotations and output schema, the description is insufficient for a security tool. It doesn't explain what 'extract parameters' entails in practice, the format of results, or behavioral constraints, leaving significant gaps for an AI agent to operate safely and effectively.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (target and depth). The description adds no additional parameter semantics beyond what the schema provides, such as examples or edge cases, meeting the baseline for high coverage.

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

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

The description clearly states the action ('Extract parameters') and resource ('from web applications'), specifying the method ('using Katana and manual methods'). It distinguishes itself from siblings like 'fuzzing_parameters' by focusing on extraction rather than fuzzing, though it doesn't explicitly contrast with all relevant 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?

No explicit guidance on when to use this tool versus alternatives is provided. It mentions 'Katana and manual methods' but doesn't specify scenarios or prerequisites, leaving the agent to infer usage from context without clear direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'Test[s] for SQL injection vulnerabilities,' which implies a scanning or probing action, but doesn't describe what the tool actually does (e.g., sends payloads, analyzes responses), potential impacts (e.g., might trigger alerts, could be intrusive), rate limits, or authentication needs. For a security testing tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence: 'Test for SQL injection vulnerabilities.' It's front-loaded with the core purpose, has zero wasted words, and is appropriately sized for a tool with a straightforward name and schema. Every part of the sentence earns its place by clearly stating the action and target.

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 complexity of a security testing tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., vulnerabilities found, logs, errors), behavioral traits like intrusiveness or speed, or how it fits into broader workflows. For a tool that likely has significant operational implications, this minimal description leaves too many gaps for effective 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?

The input schema has 100% description coverage, with clear parameter descriptions (e.g., 'Target URL' for 'url'). The description doesn't add any meaning beyond what the schema provides—it doesn't explain how parameters interact (e.g., 'data' for POST requests) or provide usage examples. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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: 'Test for SQL injection vulnerabilities.' It specifies the verb ('Test') and resource ('SQL injection vulnerabilities'), making it easy to understand what the tool does. However, it doesn't distinguish this from sibling tools like 'test_web_application' or 'burp_active_scan', which might also test for vulnerabilities including SQL injection.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available for security testing (e.g., 'nmap_scan', 'nikto_scan', 'test_web_application'), it doesn't specify if this is for initial scanning, deep testing, or when SQL injection is suspected. There's no mention of prerequisites, exclusions, or typical contexts for usage.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'enumerate' implies a read-only reconnaissance operation, the description doesn't specify whether this is passive or active, what the output format will be, whether it requires network access, or any rate limits or ethical considerations. It mentions 'multiple methods' but doesn't elaborate on what those are or their implications.

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

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

The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a tool with 4 parameters and clear purpose.

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

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

For a security testing tool with no annotations and no output schema, the description is insufficient. It doesn't explain what the tool returns, what 'multiple methods' entails, whether this is passive or active reconnaissance, or any ethical/legal considerations. Given the complexity of security tools and the lack of structured metadata, more context is needed.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema descriptions. It mentions 'multiple methods' which loosely relates to the use_subfinder and fuzz_tool parameters, but doesn't provide meaningful context about when to choose which methods.

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 ('enumerate') and target ('subdomains of target domain'), and mentions 'using multiple methods' which adds specificity. However, it doesn't explicitly differentiate this tool from other enumeration tools in the sibling list like directory_bruteforce or tech_detection, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools focused on different aspects of security testing (nmap_scan, nikto_scan, sqlmap_scan, etc.), there's no indication of when subdomain enumeration is appropriate versus other reconnaissance or attack 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 of behavioral disclosure. It mentions analysis and suggestion but doesn't describe what the tool actually does (e.g., returns a list, generates a plan, requires specific inputs beyond scan_results). There's no information on permissions, rate limits, or output format, leaving significant gaps for a tool that likely involves processing and recommendations.

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 a single sentence, 'Analyze current findings and suggest next steps', which is front-loaded and wastes no words. However, it's overly brief to the point of under-specification, slightly reducing its effectiveness despite efficient structure.

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 complexity of analysis and suggestion tasks, with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of steps, a plan) or any behavioral traits. For a tool with one parameter but significant processing logic, more context is needed to guide the agent effectively.

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 the single parameter 'scan_results', which is documented as 'Previous scan results in JSON format'. The description adds no additional meaning beyond this, such as what the JSON should contain or how it's used. With high schema coverage, the baseline is 3, and the description doesn't compensate with extra context.

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 'Analyze current findings and suggest next steps' states a vague purpose without specifying what type of analysis or what domain it operates in. It doesn't distinguish from siblings like 'generate_report' or 'adaptive_strategy', which could have overlapping functionality. The description is generic rather than specific to a particular resource or context.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'generate_report' for reporting and 'adaptive_strategy' for strategy planning, there's no indication of prerequisites, timing, or exclusions. The agent must infer usage from the tool name alone, which is insufficient.

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. While 'detect' implies a read-only operation, it doesn't specify whether this is passive or active scanning, potential rate limits, authentication requirements, or what the output looks like. For a security tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple tool with one parameter and gets straight to the point with zero wasted verbiage.

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 complexity of security testing tools and the lack of both annotations and output schema, the description is insufficiently complete. It doesn't explain what 'technologies' means (e.g., web frameworks, servers, CMS), how results are returned, or any limitations. For a tool in this domain with rich sibling alternatives, more context is needed for effective 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%, with the single parameter 'url' clearly documented as 'Target URL' in the schema. The description doesn't add any additional meaning beyond what the schema provides (e.g., URL format requirements, protocol restrictions, or example values), so it meets the baseline for adequate but unenhanced 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's purpose with a specific verb ('detect') and resource ('technologies used by target website'), making it immediately understandable. However, it doesn't differentiate itself from potential sibling tools like 'nikto_scan' or 'nmap_scan' that might also detect technologies, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available for security testing (e.g., 'nmap_scan', 'nikto_scan', 'directory_scan'), there's no indication of whether this is for initial reconnaissance, specific technology fingerprinting, or how it differs from other detection methods.

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. While 'penetration testing' implies potentially intrusive/destructive actions, the description doesn't specify whether this tool actually exploits vulnerabilities, just scans for them, requires special permissions, has rate limits, or produces specific outputs. This is a significant gap for a security testing tool with zero annotation coverage.

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

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

The description is extremely concise - a single phrase that communicates the core function. There's no wasted language or unnecessary elaboration. While it could benefit from more detail, what's present is efficiently packaged.

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 security testing tool with no annotations, no output schema, and potentially complex behavior, the description is inadequate. It doesn't explain what 'comprehensive' means, what specific tests are performed, what results to expect, or safety considerations. Given the context of many sibling security tools, more differentiation and behavioral detail 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?

Schema description coverage is 100%, so the schema already documents both parameters (target and domain) adequately. The description adds no additional parameter information beyond what's in the schema - it doesn't explain format requirements, provide examples, or clarify the relationship between target and domain parameters. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description states the tool performs 'Comprehensive Active Directory penetration testing', which clearly indicates a security testing function. However, it doesn't specify what specific actions it takes (e.g., enumeration, exploitation, vulnerability scanning) or how it differs from sibling tools like 'test_smb_service' or 'directory_scan' that might also interact with Active Directory components.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools available for security testing (e.g., 'nmap_scan', 'directory_bruteforce', 'test_smb_service'), there's no indication of whether this is a broad-scope tool, when it's appropriate versus more targeted tools, or what prerequisites might be needed for Active Directory testing.

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 burden for behavioral disclosure. It vaguely implies testing but doesn't specify whether this is passive scanning, active exploitation, or diagnostic checks. Critical details like potential network impact, authentication requirements, output format, or error handling are missing, leaving the agent with insufficient information about how the tool behaves.

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

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

The description is a single, efficient phrase with zero wasted words. It's front-loaded with the core purpose ('Comprehensive SMB/NetBIOS service testing'), making it easy to parse quickly. Every word contributes directly to conveying the tool's function without redundancy or unnecessary elaboration.

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

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

Given the complexity of security testing tools and lack of annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., safety, side effects), usage context, or what results to expect. For a tool with potential network impact and no structured safety hints, more detail is needed to guide an agent effectively.

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 (target IP and port with default). The description adds no additional meaning about parameters—it doesn't explain what 'comprehensive testing' involves for these inputs or any constraints beyond the schema. Baseline 3 is appropriate since the schema handles parameter documentation adequately.

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 'Comprehensive SMB/NetBIOS service testing' clearly states the tool's purpose (testing SMB/NetBIOS services) but lacks specificity about what 'testing' entails (e.g., vulnerability scanning, connectivity checks, configuration analysis). It distinguishes from siblings like 'test_active_directory' or 'test_web_application' by focusing on SMB/NetBIOS, but doesn't specify the verb or scope beyond 'comprehensive'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., network access, permissions), when it's appropriate (e.g., during reconnaissance vs. exploitation), or how it differs from related tools like 'nmap_scan' or 'test_active_directory' for SMB-related tasks. The lack of context leaves usage decisions ambiguous.

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 burden. While 'penetration testing' implies potentially intrusive/destructive actions, the description doesn't disclose critical behavioral traits: whether it requires authentication, what kind of tests it runs (e.g., automated vs. manual), rate limits, potential impact on target systems, or output format. This leaves significant gaps for safe and effective tool 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 a single, efficient phrase that communicates the core purpose without unnecessary words. It's appropriately sized for a tool with two well-documented parameters and no output schema, with every word earning 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 penetration testing tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address safety considerations, expected outputs, or how it differs from numerous sibling testing tools. Given the potentially destructive nature of pentesting and the rich ecosystem of alternatives, more context is needed for effective 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 schema already documents both parameters adequately. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain how 'technologies' array influences the testing approach or provide examples beyond the schema's basic description. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool performs 'web application penetration testing' with a 'technology-specific' focus, providing a specific verb+resource combination. However, it doesn't explicitly differentiate itself from sibling tools like 'nikto_scan', 'nuclei_scan', or 'sqlmap_scan' which also appear to be web application testing tools, leaving some ambiguity about its unique scope.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for web application testing (e.g., nikto_scan, nuclei_scan, sqlmap_scan, burp_active_scan), there's no indication of prerequisites, appropriate contexts, or exclusions. The agent must infer usage from the name and description alone.

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