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

With no annotations, the description carries the full burden. It does disclose the confirmation heuristic ('status flip away from the block page'), which is genuinely useful behavioral context, but says nothing about request volume/noise (max_requests defaults to 40), auth requirements, or whether follow_redirects affects interpretation.

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 compact sentences: technique inventory first, then the success criterion. Dense and front-loaded with essentially no filler, though the comma-separated technique list is somewhat terse rather than 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?

The output schema exists so return values needn't be explained, and the technique scope is covered. However, for an 8-parameter active-probing tool with zero annotations and zero schema descriptions, key operational details (request budget, redirect handling, engagement scoping) are 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 0% across 8 parameters, so the description has to compensate. It implicitly maps to method (method sweep), headers (forwarding/origin headers), and extra_paths (path-shape mutations), but leaves body, max_requests, follow_redirects, and engagement_id entirely unexplained.

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 capability (401/403/405 bypass probing) and enumerates the exact technique classes it performs, so an agent can distinguish it from narrower siblings like websex_host_header_probe or websex_traversal_probe. It doesn't explicitly name those siblings as alternatives, which keeps it at 4 rather than 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 trigger condition is implied by '401/403/405' (use it when you encounter block responses), but there is no explicit when-to-use/when-not guidance and no routing to alternative tools for adjacent cases like host-header or path traversal. Usage is inferable but not stated.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that aircrack-ng is executed directly with argv tokens and that shell parsing is never used (clarifying injection behavior), plus that it runs from the engagement namespace with relative artifact paths. It does not, however, state the safety profile (this is a CPU-heavy read against capture files), permission requirements, or expected runtime.

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

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

Three short sentences with the purpose front-loaded ahead of execution and path mechanics. Every sentence contributes context and there is no filler, though it could be tightened slightly.

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

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

An output schema exists, so return values need no explanation. The description adequately covers execution semantics and working-directory conventions, but for a four-parameter tool with zero schema documentation, an agent still lacks guidance on routing (vs. airodump/aireplay) and on the undocumented stdin parameter.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate. It partially does by framing 'arguments' as argv tokens that bypass shell parsing and by implying 'working_directory' via relative engagement paths, but it never mentions 'stdin' and never maps 'engagement_id' explicitly. Several parameters remain semantically opaque.

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

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

The description states a specific verb and resource: 'Run aircrack from the WebSex wireless toolkit.' An agent can tell this invokes the aircrack-ng cracking binary, distinguishing it from wireless siblings like airodump (capture) and aireplay (injection). It stops short of naming those siblings explicitly, so differentiation is inferential rather than spelled out.

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

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

There is no explicit when-to-use guidance, no statement of prerequisites (e.g., a captured .cap file already produced by airodump), and no named alternatives among the wireless siblings. The context that this is the post-capture cracking step is only weakly implied by the tool name and description.

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 usefully discloses that shell parsing is never used (argv tokens passed directly) and the engagement namespace/relative-path scoping, which is genuinely beyond a schema. However it omits key operational traits for a wireless injection tool: monitor-mode requirement, whether it is disruptive/destructive to the target network, and permission prerequisites.

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 tight sentences, front-loaded with the operation then the execution semantics and path convention. No filler, though it could have spent its brevity budget on the undocumented parameters instead.

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?

Return values are covered by the output schema, but for a four-parameter tool with 0% schema coverage and zero annotations the description leaves too much unstated: engagement_id and stdin are never described, and no prerequisites (wireless interface, monitor mode) are given. Inadequate for the tool's complexity.

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

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

Schema coverage is 0% and the description only loosely maps 'supplied argv tokens' to the arguments array and 'relative paths' to working_directory. It says nothing about engagement_id (a required param) or stdin, so half the parameters remain unexplained in both schema and 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?

States a specific verb and resource: run 'aireplay' via the container executing 'aireplay-ng' with supplied argv tokens. The tool's identity as a wireless injection/replay utility is unambiguous and distinguishable from airmon/airodump/aircrack siblings. It stops short of explicitly contrasting its role against those siblings, keeping it at a 4.

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 implied usage context ('runs from the selected engagement namespace', 'use relative paths for engagement artifacts') but never says when to reach for this versus airodump, airmon, or aircrack. No exclusions or alternatives are named, so the agent must infer routing from the tool 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?

With no annotations, the description carries the burden and does add real value: it discloses that `airmon-ng` is invoked directly with argv tokens and that shell parsing is never used, which tells the agent how inputs are handled. It stops short of stating privilege requirements (airmon-ng typically needs root), side effects such as toggling monitor mode, or failure modes.

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 tight sentences that front-load the core action (run airmon) before the execution-model and path details. No filler, though the middle sentence is doing double duty as both behavior disclosure and parameter clarification.

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

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

An output schema exists, so return values need not be explained, and the description covers the execution model and namespace/path conventions. It omits privilege and side-effect information that matter for a wireless monitor-mode tool, so an agent could invoke it without knowing it likely needs root.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies three of the four params indirectly: `arguments` are raw argv tokens, `engagement_id` selects the namespace, and `working_directory` supports relative engagement paths. The `stdin` parameter is never mentioned, leaving one gap at full-schema coverage risk.

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

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

States a specific verb+resource: runs `airmon` (airmon-ng) from the WebSex wireless toolkit, with the argv-token execution model made explicit. It does not, however, differentiate this tool from its close siblings aircrack, airodump, and aireplay, so an agent still has to infer the role of airmon within the aircrack-ng suite.

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 operational context (runs from the selected engagement namespace, use relative paths for artifacts) but no when-to-use/when-not guidance relative to the other wireless tools. There is no statement of prerequisites such as monitor-mode or root requirements, and no alternative named.

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 behavioral burden. It usefully discloses that argv tokens are passed directly with no shell parsing (a real execution-model detail) and that it runs in the engagement namespace. It omits significant operational traits: monitor-mode/adapter requirements, the long-running capture nature, output file behavior, and any destructive or resource 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?

Front-loaded with the action, followed by execution-model and namespace constraints. Three compact sentences with little waste; nothing is padded, though the middle clause could be tighter.

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

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

An output schema exists so return values need not be described, but for a 4-parameter, zero-coverage, annotation-free tool the description is thin. It never explains what engagement_id is, what airodump requires (e.g., monitor mode), or how results/captures are produced, leaving real gaps 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 0%, so the description must compensate. It gestures at two of four parameters (argv tokens map to 'arguments', relative paths touch on 'working_directory'), but 'engagement_id' is never explained (format, meaning, where it comes from) and 'stdin' is ignored entirely, leaving core inputs under-specified.

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 ("Run airodump from the WebSex wireless toolkit") and pins the exact binary (airodump-ng), distinguishing it from wireless siblings like aircrack, aireplay, and kismet. It does not, however, say what airodump actually accomplishes (wireless packet capture/monitoring), so an agent unfamiliar with the tool gains less.

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

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

There is no guidance on when to reach for airodump versus sibling wireless tools such as websex_aircrack, websex_aireplay, or websex_kismet. The namespace/path note is an operational constraint, not a when-to-use 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?

With no annotations, the description carries the full burden. It usefully discloses that arguments are passed as argv tokens with shell parsing never used (so no shell expansion/injection semantics) and that it runs from the engagement namespace. It does not state permissions, network behavior, or whether the operation mutates anything, which is a gap for an unannotated execution tool.

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

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

Three short sentences, front-loaded with the action, and each adds a distinct piece of information about execution or path handling. 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?

An output schema exists, so return values need no explanation, and the execution model (argv, cwd, namespace) is covered. However, the 0%-documented stdin parameter and the absence of any indication of what amass actually enumerates leave an agent with gaps for a 4-param execution wrapper.

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

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

Schema description coverage is 0% across 4 params, so the description must compensate. "Supplied argv tokens" maps to the arguments array, "runs from the selected engagement namespace" hints at engagement_id, and "relative paths for engagement artifacts" hints at working_directory. The stdin parameter is left entirely unexplained, so compensation is only partial.

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

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

States a specific verb+resource ("Run amass from the WebSex enumeration toolkit"), which tells an agent this is a subdomain/enumeration wrapper. It doesn't differentiate from siblings like websex_subfinder, websex_dnsenum, or websex_theharvester, so the agent still has to know what amass does versus those 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 operational instructions ("runs from the selected engagement namespace", "use relative paths") but no guidance on when to choose amass over the many sibling enumeration tools. There is no when-to-use, no exclusions, and no 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, the description carries the full burden, and it does add real behavioral detail: argv-token execution with no shell parsing (a meaningful safety/invocation note) and namespace-scoped working directory. However, it omits that anew mutates files by appending/deduplicating lines, and says nothing about side effects or reversibility.

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 tight sentences with the execution model front-loaded and no filler. Slightly dense and arguably too terse on the tool's actual function, but structurally 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?

An output schema exists, so return values need not be explained. But for a 4-parameter tool with zero schema coverage and no annotations, the description leaves the tool's core behavior (what anew does, what it writes) and one parameter undocumented, which is a substantial gap.

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

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

Schema coverage is 0%, so the description must compensate. It partially does: it clarifies that 'arguments' are raw argv tokens (not shell-parsed) and that working-directory paths are relative to the engagement namespace. But the optional 'stdin' parameter is never mentioned, and engagement_id is only obliquely covered by 'engagement namespace'.

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?

It states a specific verb+resource ('Run anew from the WebSex web toolkit'), which identifies the wrapped binary but never says what anew actually does (line deduplication / appending new lines to a file). An agent unfamiliar with the binary cannot infer the tool's function from the description alone. Sibling differentiation is only by tool name, not by capability.

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 it runs from the selected engagement namespace and to use relative paths for artifacts, which is context, but it gives no when-to-use guidance and no comparison to adjacent tools like websex_grep, websex_bash, or websex_execute. No exclusions or prerequisites are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no note that angr analysis is computationally expensive/long-running, no prerequisites (valid ELF/PE, 32/64-bit support), no permission or engagement requirements, no statement of what is produced. Only the implicit 'workspace binary' scoping constraint is 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?

A single short sentence with the core verb-resource-engine front-loaded and no wasted words. Its brevity reflects under-specification rather than tight editing, but structurally it is clean.

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

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

An output schema exists, so return values need not be described. However, with zero annotation coverage, zero schema description coverage, and two required parameters, the description leaves an agent without the prerequisites, runtime cost, or parameter meaning needed to invoke this reliably.

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

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

Schema description coverage is 0% across all three parameters, so the description must compensate and it barely does. 'Workspace binary' hints that path resolves inside a workspace and that engagement_id scopes the operation, but auto_load_libs (default false) is left entirely unexplained despite materially changing angr's 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?

States a specific verb (Analyze) and resource (a workspace binary), and names the underlying engine (angr Python library), which signals symbolic execution/CFG analysis rather than the static dumping that siblings like objdump or strings perform. It does not explicitly differentiate itself from websex_ghidra, websex_radare2, or websex_objdump, but the engine name carries most of that distinction.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives among the many binary-analysis siblings. An agent must infer that angr means symbolic execution and that heavy analysis is warranted; nothing in the text routes it there.

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 disclose useful traits: the run is caller-bounded via max_requests and complete response evidence is preserved. It omits rate limiting, error/failure handling, and what 'authorized' concretely requires, so gaps remain for a network-touching fuzzer.

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 tight sentences with no filler, front-loading the core action before the caller-control note. Every clause 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 an 11-parameter, 8-required tool with zero schema coverage and no annotations, the description leaves key input semantics undocumented (e.g., location, method, base_url). The output schema covers return values, but the input side is substantially under-specified.

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

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

Schema description coverage is 0% across 11 parameters, so the description must compensate, yet it only clarifies two of them (payloads, max_requests). The semantics of location, method, base_url, engagement_id, parameter, and follow_redirects are left entirely unexplained.

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 (fuzz) and resource (single-parameter API fuzz matrix) with clear scope modifiers: 'caller-bounded' and 'single-parameter'. This meaningfully separates it from generic request tools like http_intruder, though it does not name any sibling explicitly.

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

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

'against an authorized target' implies an authorization prerequisite, but there is no guidance on when to prefer this over siblings such as http_intruder, wfuzz, or the atomic probe tools. The only steering ('caller selects payloads and max_requests') is about inputs, not usage 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 it does disclose meaningful execution semantics: argv tokens are passed directly, shell parsing is never used (no shell injection), and the process runs from the engagement namespace. It stops short of disclosing anything about network reach, runtime, or what the tool produces, so a 3 is warranted.

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

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

Three short sentences, front-loaded with the action, no filler or repetition. It is tight, though it spends its budget on execution mechanics rather than the information an agent most needs (what the tool discovers).

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

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

An output schema exists so return values need not be explained, but for a 4-parameter tool with 0% schema coverage the description leaves too much unsaid: no statement of what arjun discovers, no selection guidance against two close siblings, and no runtime or scope 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?

Schema description coverage is 0%, so the description must compensate. It usefully clarifies the most important parameter by stating that 'arguments' is a raw argv token list rather than a shell string, and the relative-path note touches working_directory. However, stdin and engagement_id are left entirely undocumented.

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

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

The description only restates the tool name: 'Run arjun from the WebSex web toolkit.' It never says what arjun does (HTTP parameter discovery) or what it targets. With siblings websex_paramspider and websex_x8 covering the same domain, there is no differentiation at all, so an agent unfamiliar with the binary cannot pick it correctly.

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

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

There is no when-to-use guidance and no mention of the obvious alternatives (paramspider, x8) that would let an agent choose. The only usage-like sentence concerns namespace and relative paths, which is an operating instruction rather than 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 two useful behavioral traits: shell parsing is never used (argv tokens passed directly) and it runs within the selected engagement namespace. Key details are still missing, such as required privileges, timeout behavior, and what the output contains.

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, front-loaded with the tool's purpose and augmented by operational notes. Efficient, though slightly terse for a security tool without annotations.

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

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

For a network scanning tool with no annotations, no schema descriptions, and a complex argument-list parameter, the description is thin. The output schema existence means return values needn't be described, but the lack of privilege requirements, timeout expectations, and argument format leaves significant gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It only vaguely references 'supplied argv tokens' and 'relative paths for engagement artifacts', leaving engagement_id, arguments, stdin, and working_directory largely undocumented in both schema and 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?

States a specific verb (Run arp scan) and resource (WebSex network toolkit / arp-scan), so the purpose is unambiguous. It does not explicitly name a sibling alternative such as websex_nmap or websex_netbios_scan, so it falls short of a 5.

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

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

The description implies usage through 'Run arp scan' and 'Runs from the selected engagement namespace', and the path guidance ('use relative paths for engagement artifacts') gives some operational context. However, it does not state when to prefer arp scan over alternatives like websex_nmap, websex_netbios_scan, or websex_network_mapper, so guidance is only implied.

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 behavioral burden. It discloses that input is caller-supplied and output is a severity-based ordered chain, but it does not explain ordering logic, side effects, permissions, or rate limits.

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

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

A single, front-loaded sentence with no filler. It communicates the action and result immediately.

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

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

An output schema exists, so return values need not be explained. However, the input schema is opaque and annotations are absent; the description does not specify what a 'finding' must contain or how severity is derived, leaving the agent under-informed 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 0% and the sole parameter is an array of unconstrained objects. The description labels it 'caller-supplied findings', which gives minimal semantic context, but it does not describe the expected finding structure, severity field, or required keys.

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 ('order') and resource ('caller-supplied findings'), plus the output form ('reviewable severity-based attack chain'). It does not explicitly differentiate itself from sibling findings-oriented tools such as websex_finding_report or websex_scan_summary.

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

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

No when-to-use guidance or alternatives are given. The description implies the tool is used once findings already exist, but it does not say when to choose it over sibling tools like websex_finding_report or websex_scan_summary.

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 meaningful work: it discloses that the container executes autorecon directly with argv tokens and that shell parsing is never used (an injection/quoting-relevant detail), plus that it runs from the engagement namespace with relative paths. It omits permissions, runtime duration, and network-impact caveats for an active 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 sentences, front-loaded with the purpose and followed by execution semantics; no filler. It is appropriately sized, though it could tie the operational notes more tightly to the argument/namespace parameters.

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

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

An output schema exists, so return values need not be explained, and the description covers the key execution semantics an agent needs. Still, for an active recon tool with zero annotations it could say more about scope/permissions and the undocumented stdin parameter.

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

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

Schema coverage is 0%, so the description must compensate for four undocumented parameters. It clarifies that 'arguments' are raw argv tokens passed without shell parsing and that relative paths apply to engagement artifacts (working_directory/engagement_id), but it says nothing about 'stdin', leaving one parameter with no semantic guidance anywhere.

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 ('Run autorecon from the WebSex network toolkit'), so an agent immediately knows this invokes the autorecon orchestrator. It does not, however, position itself against the many sibling recon tools (nmap, rustscan, masscan) that could also be chosen.

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

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

Usage is only implied by the tool name: run automated recon via autorecon. There is no explicit when-to-use/when-not or routing to alternatives like nmap or rustscan, though the note about running from the engagement namespace offers some operational 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 add real behavioral context: asynchronous execution, client-cancellability, pipeline/redirection support, and the container as the trust boundary. However, it does not disclose the destructive potential of running arbitrary code, permission/auth requirements, or how output and cancellation results are surfaced.

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 tight sentences with the primary action front-loaded, followed by capabilities and execution model. No filler; every clause carries information.

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

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

The output schema spares the description from explaining return values, and the execution model is described. But for a five-parameter arbitrary-code-execution tool with zero annotation coverage and 0% schema descriptions, the missing parameter semantics and safety details leave notable gaps.

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

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

Schema description coverage is 0% across five parameters, so the description should compensate, yet it only vaguely gestures at 'engagement directory' and says nothing about stdin, environment, or working_directory. The remaining parameters are undocumented in both schema and 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?

States a specific verb and resource: running an arbitrary Bash script inside the WebSex container, scoped to the selected engagement directory. Clear on its own, but it never names the obvious siblings (websex_execute, websex_python), so an agent gets no differentiation among the several execution tools.

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

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

There is no when-to-use guidance and no reference to alternatives like websex_execute or websex_python. The 'container is the trust boundary' line is context, not routing, so the agent must infer when Bash execution is preferred over the other execution tools.

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

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

With no annotations, the description carries full behavioral burden. It discloses the internal mechanism well (paired low/privileged replay, success-differential trigger), but never warns that it issues live POST/PUT/PATCH/DELETE requests that may mutate target state, nor does it mention request volume or max_requests-capped throttling.

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

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

A single dense sentence with the technique front-loaded and no filler. Efficient, though the semicolon-clause packs several concepts together and could be split for scanability.

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

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

An output schema exists so return values need not be explained, but for a 7-parameter, state-changing, annotation-free probe the one-sentence description is materially under-specified: no credential prerequisites, no destructive-action caveat, no indication of scope or volume, and no parameter guidance.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and does not. It only obliquely maps 'identity' to the two header objects and names the privileged verbs; engagement_id, url, body, methods, and max_requests are entirely unexplained.

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 the specific vulnerability class (function-level authorization) and states the exact mechanism – privileged verbs replayed under two identities – with the detection trigger. It is distinguishable from siblings like websex_idor_probe and websex_access_bypass_probe, though it never uses an explicit 'this tool probes X' verb.

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 firing condition implies when results matter, but there is no statement of when to choose this over websex_access_bypass_probe or websex_idor_probe, and no prerequisites (e.g. requires a known endpoint and two sets of credentials). Usage is inferable only from the technique name.

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 it does disclose real behavioral traits: binwalk is executed directly with argv tokens and 'shell parsing is never used', which tells the agent about injection safety and argument handling. It still omits what binwalk actually does at runtime (extraction writes files, may recurse into embedded archives) and the namespace/working-directory semantics are only partially explained.

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 compact sentences with the core action front-loaded first, then the execution model, then the namespace/path guidance. Little waste, though 'from the WebSex binary toolkit' is mild boilerplate that could be trimmed.

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

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

An output schema exists, so return-value explanation is not required, and the shell-safety plus namespace notes are useful. However, for a tool with zero annotation and zero schema-description coverage, the description leaves the agent without enough detail on invocation semantics (how argv tokens are passed, engagement scoping) and on binwalk's own extraction side effects.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate. It maps loosely onto 'arguments' (argv tokens), 'working_directory' (relative paths), and 'engagement_id' (engagement namespace), but it never addresses 'stdin' and provides no format or syntax detail for any parameter, so the compensation is only partial.

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

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

States a specific verb and resource ('Run binwalk') and identifies the toolkit it belongs to. However, it does not differentiate itself from similarly-purposed carving/extraction siblings such as websex_foremost, websex_scalpel, websex_bulk_extractor, or websex_zsteg, leaving the agent to rely on outside knowledge of binwalk's firmware-analysis niche.

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 says it 'runs from the selected engagement namespace' and to 'use relative paths for engagement artifacts', which is context about how to invoke it, but it gives no when-to-use guidance versus alternatives and no exclusions. There is no indication of which file types or scenarios should route an agent here instead of a sibling extraction 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 full behavioral burden, yet it says nothing about side effects, whether actions auto-wait for element readiness, what happens on a missing selector, or whether fill replaces versus appends text. The action list is a useful vocabulary but not behavioral disclosure.

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

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

A single front-loaded sentence with no filler; the action enumeration is substantive content rather than padding. It is tight, though the flat list could be grouped by category (text entry vs toggles vs pointer).

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

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

An output schema exists so return values need no explanation, but for a mutating browser tool with zero annotations, 0% schema coverage, and four required parameters, the description omits session prerequisites, selector format, and failure behavior — too little 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 0% across 5 parameters, and the description only indirectly covers the 'action' parameter by listing valid values. It never explains selector syntax (CSS vs XPath), which actions consume 'value', or what session_id/engagement_id must reference, leaving required inputs undocumented.

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

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

The description states a specific verb+resource ('selector-based browser action') and enumerates the concrete actions supported, so an agent knows this mutates a page element rather than navigating or capturing. It does not explicitly distinguish itself from siblings like websex_browser_evaluate or websex_browser_set_state, which also act on a live session.

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

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

There is no when-to-use guidance, no mention that an existing browser session/engagement is required, and no routing to alternatives such as websex_browser_evaluate for JS-driven interactions or websex_browser_navigate for page loads. The agent must infer usage entirely from the name.

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 does add useful lifecycle context ('real process lifecycle semantics', 'release Chromium resources'), signalling an irreversible teardown, but it omits whether the operation is idempotent, what happens on an invalid or already-closed session, and any permission requirements.

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

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

Two tight sentences with the core action front-loaded; the second sentence adds differentiation value rather than filler. Minor waste in the vague 'engagement close' reference.

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

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

An output schema exists so return values need not be described, but with no annotations and 0% parameter coverage this destructive lifecycle tool should say more about error behavior, idempotency, and prerequisites than it does.

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

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

Schema description coverage is 0% for both required parameters, and the description says nothing about what engagement_id and session_id refer to or how they relate. An agent must infer that session_id identifies the target context and engagement_id scopes 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?

States a specific verb (close) and resource (live browser context), plus the effect (release Chromium resources). It attempts sibling differentiation via 'unlike engagement close', but that referenced tool is not present in the sibling list, so the contrast is only partly useful; the actual siblings (browser_create, browser_get, browser_list) are not named.

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 'Close a live browser context' implies the context in which to use it (tearing down an active browser session), but there is no explicit when-not guidance, no mention of what to do if the context is already closed, and no pointer to the sibling that manages browser lifecycle.

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 usefully discloses that the context is isolated and headless (Chromium), and that the session ID is server-generated and engagement-bound. However, it omits session lifetime/expiry, resource cost, and whether a matching close is required to release resources.

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

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

A single dense sentence that front-loads the core action and the returned artifact with zero 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?

The presence of an output schema means return values needn't be explained, but for a 6-parameter session-creation tool with no annotations and 0% schema coverage, the description leaves too many gaps: parameter meaning, session lifecycle, and cleanup requirements.

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

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

Schema description coverage is 0% across 6 parameters, and the description explains none of them. Only the 'engagement' binding hints at engagement_id; name, user_agent, extra_headers, and viewport dimensions are left entirely undocumented in both the schema and 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?

States a specific verb+resource: 'Launch an isolated headless Chromium context' and clarifies it returns a session ID bound to an engagement. This clearly distinguishes it from siblings like browser_navigate or browser_action, though it doesn't name those alternatives 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 implies this is a session-creation step but gives no explicit when-to-use guidance, no mention that it must precede navigate/action calls, and no exclusion of alternatives. An agent must infer the lifecycle from the tool 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?

With no annotations, the description carries the full behavioral burden but only mentions that the result is serializable. It omits critical traits for arbitrary JavaScript execution, such as side effects on the page, network access, error behavior, and whether the operation is sandboxed or destructive.

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, front-loaded sentence with no wasted words. It states the action, scope, and return constraint immediately.

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

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

Although an output schema exists and covers return values, the description is insufficient for a tool that executes arbitrary JavaScript in a browser session. It lacks usage context, safety implications, parameter explanations, and session/engagement prerequisites.

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

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

Schema description coverage is 0% across four parameters, and the description adds no meaning beyond the schema. It does not explain the purpose of argument, session_id, or engagement_id, nor does it clarify expression syntax or expected format.

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 ('Evaluate'), resource ('JavaScript'), and scope ('active page'), clearly setting it apart from sibling browser tools like snapshot, action, or navigate. An agent can understand the core operation 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?

No guidance is given on when to use this tool versus alternatives such as websex_browser_action, websex_execute, or websex_python. There are no prerequisites, exclusions, or contextual triggers to help an agent choose 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?

No annotations exist, so the description carries the full disclosure burden. 'Inspect' plus 'live session' implies a read-only lookup, and it names the returned fields, but there is no statement about side effects, authentication/engagement scoping, or whether the session must already exist.

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

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

A single front-loaded sentence with the verb and scope first and no filler. Slight redundancy in listing return fields that an output schema already covers, but nothing wasteful.

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

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

An output schema exists, so explaining return values is unnecessary. However, for a tool requiring two undocumented identifiers, the description supplies no parameter meaning and no behavioral context to compensate for the absent annotations.

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

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

Schema description coverage is 0% for two required parameters (engagement_id, session_id), and the description never mentions either one. It does not explain the engagement/session identifier pairing or compensating syntax that would make up for the schema gap.

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

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

States a specific verb (inspect), resource (one live browser session), and enumerates what is surfaced (URL, title, network event count, interception rules). The word 'one' distinguishes it from websex_browser_list, but it does not disambiguate from websex_browser_state, which sounds like an overlapping read of the same session.

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

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

No when-to-use, when-not-to-use, or alternative is named, despite obvious candidates among siblings (websex_browser_list to enumerate sessions, websex_browser_state or websex_browser_snapshot for state). The only guidance is the implied 'one' vs many contrast.

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 it does disclose meaningful scope: only 'live' sessions and only those 'owned by this MCP process' are returned, so the agent knows other-process or dead sessions are excluded. It says nothing about what happens when no sessions exist, ordering, or size limits.

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

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

A single sentence with no filler, and the scope qualifiers are front-loaded after the verb-object core. Nothing is padded, though one clause of usage context would have fit without bloat.

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

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

An output schema exists, so return values need no explanation, and the single-parameter surface is small. However, for a listing tool in a large browser-session family, the description omits the workflow relationship to browser_get/browser_close, leaving the agent to guess when this is the right entry point.

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

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

Schema description coverage is 0% and there is only one required parameter, so the schema gives the agent only the name 'engagement_id'. The phrase 'for one engagement' confirms the parameter scopes the listing, but adds no format, validation, or example 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?

Specific verb (List) plus resource (live browser sessions) with two clear scope constraints: sessions owned by this MCP process and scoped to one engagement. It is distinguishable from websex_browser_get/close/create by the plural, enumeration framing, though it never names a sibling explicitly.

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

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

There is no when-to-use guidance and no mention of alternatives such as websex_browser_get (fetch one session) or websex_browser_state. The purpose implies a discovery step before operating on a session, but the agent must infer that routing itself.

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 does not disclose that navigation mutates the session's current page state, what wait_until values are accepted, or any auth/permission requirements for the engagement and session IDs. Returning status/headers/url/title is partly redundant with the existing output schema.

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

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

A single front-loaded sentence with no filler; the verb and destination come first. It is efficient, though it could have used one more sentence for usage context without becoming bloated.

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

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

The output schema covers return values, but for a four-parameter, zero-annotation tool the definition omits prerequisite session state, the meaning of wait_until, and any indication of how this differs from other browser tools. Too much is left for the agent to guess.

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

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

Schema description coverage is 0%, so all four parameters are undocumented. The description only implies the url argument and says nothing about engagement_id, session_id, or the semantics of wait_until (default 'load'), leaving an agent unable to know valid values or the consequence of each.

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 (Navigate) and resource (live browser session) with the destination (a URL), so an agent can tell it apart from browser_snapshot, browser_screenshot, or browser_evaluate. However, it never explicitly contrasts itself with the closest sibling, browser_action, so the differentiation is inferred rather than stated.

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

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

There is no when-to-use guidance at all. Nothing tells the agent when to navigate a browser session versus issuing a plain websex_http_request or websex_curl, nor whether a session must first be created with websex_browser_create.

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 behavioral burden, and it does disclose two useful traits: the log is in-memory and the clear flag destroys it after reading. However, it says nothing about session/permission prerequisites, log retention or size limits, or behavior when no session exists, leaving meaningful gaps for a tool with a destructive side-effect.

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

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

A single front-loaded sentence with no filler; the core action and the optional side-effect are stated efficiently. It is appropriately sized, though it could have used a second sentence for the missing usage or parameter 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?

An output schema exists, so return values need not be described, and the description covers the read-plus-optional-clear contract. But with zero annotations, zero schema descriptions, and no usage routing, the definition is only minimally complete for a 3-parameter tool with a destructive option.

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

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

Schema description coverage is 0%, so the description is responsible for all three parameters. It only gestures at 'clear' via 'optionally clearing the in-memory log,' and leaves engagement_id and session_id entirely unexplained beyond their self-descriptive names, which does not compensate for the coverage gap.

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

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

The description gives a specific verb (return) and resource (complete request/response metadata captured by a live browser session), which is enough to distinguish it from the rules-mutating sibling websex_browser_network_rules. It stops short of explicitly naming that sibling or the related browser_snapshot/screenshot tools, so sibling differentiation is only implicit.

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

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

There is no guidance on when to reach for this tool versus alternatives like browser_snapshot or packet_capture, nor any stated prerequisite such as an active navigated session. The only hint is the embedded 'live browser session' phrase, which the agent must infer usage from.

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

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

No annotations are provided, so the description carries the full behavioral burden. It doesn't disclose whether rules are additive or replace existing ones, persistence across sessions, permission requirements, or any side effects. For a configuration tool that alters browser network behavior, 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?

A single efficient sentence that front-loads the core purpose and lists the key configurable elements. It could be expanded slightly for clarity without losing conciseness, but it is 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?

The tool has five parameters at 0% schema description coverage and no annotations, and an output schema exists but the description doesn't leverage it. The description fails to explain required parameters, rule format, persistence, or interaction with other browser tools, making it incomplete 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 0%, so the description must compensate for all five parameters. It only obliquely references three of them (blocked_patterns, url_replacements, extra_headers) in a single phrase, and says nothing about the required engagement_id and session_id or the format for URL patterns and replacements. This is far below the minimum needed.

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

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

The description clearly states a specific verb and resource: configuring browser request interception. It names three concrete capabilities (blocked URL patterns, URL replacements, extra request headers) that map directly to parameters. It lacks explicit differentiation from siblings like websex_browser_network_log or websex_browser_set_state, but 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?

No guidance on when or why to use this tool versus alternatives. It doesn't say whether this must be called before navigation, whether rules persist across sessions, or how it relates to websex_browser_network_log or websex_browser_set_state. The agent must infer usage entirely.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two useful traits beyond the structured fields: the capture is persisted as an artifact in the engagement, and the return value is a relative artifact path. It omits side-effect details such as overwrite behavior, whether 'path' controls output location, and whether the capture acts on the current page state.

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

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

A single front-loaded sentence with no filler; the core action and the return value come first. It is efficiently sized, though the brevity is partly why coverage gaps remain.

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

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

An output schema exists, so return values need not be re-explained, but with 4 undocumented parameters, zero schema descriptions, and no annotations, the definition leaves an agent guessing about required inputs and capture behavior. It is under-specified for a tool that persists artifacts.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate and largely does not. It only vaguely alludes to the engagement context (engagement_id) and says nothing about session_id, path, or the full_page default of true.

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 ('Capture a browser screenshot') plus the destination scope ('into the selected engagement'), which is enough to identify the operation. It does not, however, distinguish itself from the close sibling websex_browser_snapshot, leaving the screenshot-vs-snapshot distinction to inference.

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

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

No when-to-use guidance, no prerequisites, and no alternatives are named. The presence of websex_browser_snapshot in the sibling list makes the absence of any routing guidance a real gap, since an agent cannot tell which of the two to pick.

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 disclosure burden and does not meet it. It does not state whether existing cookies/storage are overwritten or merged, whether the session must already exist, what auth or permissions are required, or whether the change is reversible.

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

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

A single, front-loaded sentence with no padding, which is efficient. It is arguably too terse for a five-parameter mutation tool, but the sentence itself 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?

With no annotations, no output-schema explanation needed (an output schema exists), and 0% parameter documentation, the single sentence is insufficient for a state-mutating tool. It omits prerequisites, overwrite semantics, and any failure behavior an agent would need.

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

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

Schema description coverage is 0%, so the description must compensate. It names three of the five parameters semantically (cookies, localStorage, sessionStorage), which is useful, but leaves engagement_id and session_id completely undocumented in both the description and 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 verb (Set) and resources (cookies, localStorage, sessionStorage) in a live browser session, so the operation is unambiguous. It does not explicitly contrast itself with the sibling websex_browser_state (which presumably reads state), relying on the reader to infer the set-vs-read distinction.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites (e.g. an existing live browser session does not obviously need to be created first), and no exclusions. The only implicit usage cue is the word 'live browser session'.

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 HTML is optional, but says nothing about side effects, session requirements, output size implications of include_html, or read-only nature. Significant gaps for a session-scoped browser 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?

A single efficient sentence with the core return content front-loaded and the optional variant trailing. No wasted words.

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

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

An output schema exists, so return values needn't be described. However, with no annotations and a session-dependent browser tool, the description omits any session/engagement context or usage conditions, leaving it minimally adequate.

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

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

Schema coverage is 0%, so the description must compensate. It maps to include_html via 'optional complete HTML', but engagement_id and session_id are left entirely unexplained. Partial compensation only.

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 (return) and resource (current page text, ARIA snapshot, optional full HTML), which is clearly distinguishable from browser siblings like screenshot or evaluate. It doesn't explicitly name a sibling it differs from, so it falls short of a 5.

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

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

The description never says when to use this versus websex_browser_state, browser_evaluate, or browser_screenshot, nor any prerequisite like an active session. It gives only implied usage from the content 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, the description carries the full burden. The verb 'Read' does imply a non-mutating operation and 'live browser session' hints that an active session must exist, which is meaningful context. However it says nothing about permissions, failure modes when the session is inactive, or volume/limits of the returned data.

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

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

A single front-loaded sentence with zero filler; the action and the exact resources read come first. Nothing in the sentence is redundant.

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

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

An output schema exists, so return-value explanation is legitimately absent. But with 0% parameter coverage and no annotations, the definition still leaves required parameters and session preconditions unexplained, making it only minimally 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 0% and the description never mentions the two required parameters (engagement_id, session_id) or their format/relationship. The phrase 'live browser session' loosely gestures at session_id, but neither identifier's meaning or expected value is clarified.

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

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

The description gives a specific verb ('Read') and an explicit resource set ('cookies, localStorage, and sessionStorage'), scoped to 'a live browser session'. That clearly separates it from the obvious sibling websex_browser_set_state (which writes the same state) and from websex_browser_snapshot/evaluate, without needing to name them.

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

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

There is no when-to-use guidance, no statement of alternatives (e.g., 'use instead of browser_evaluate for reading storage'), and no prerequisites such as requiring an already-created/navigated session. The reader must infer usage entirely from the purpose sentence.

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 usefully discloses the execution model (argv tokens passed directly, shell parsing never used) and the namespace/path semantics, which is genuine behavioral context. It does not cover output behavior, error handling, resource or time limits, or whether extraction can overwrite existing artifacts, so meaningful gaps remain.

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, no filler, with the core action front-loaded before the execution-model and path-scoping details. Slightly terse relative to the disclosure burden but structurally sound.

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

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

An output schema exists, so return values need not be explained. Against that, the tool has no annotations and 0% parameter description coverage, and the description leaves gaps on stdin, error/permission behavior, and selection relative to other extraction tools, making it only minimally complete for a forensics execution tool.

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

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

Schema coverage is 0% across 4 parameters, so the description must compensate. It implies meaning for arguments (argv tokens), working_directory (relative paths within the engagement), and engagement_id (selected engagement namespace), but leaves stdin completely unexplained and gives no format details for the argv array.

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

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

States a specific verb and resource (run bulk_extractor from the WebSex forensics toolkit), which is clearly distinguishable from generic siblings like websex_execute or websex_bash. However, it offers no differentiation from the closely related carving/forensics siblings such as websex_foremost, websex_scalpel, or websex_binwalk, so an agent cannot tell from the description alone why it should pick this one.

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 operational context (runs from the selected engagement namespace, use relative paths for engagement artifacts) but never states when to use this tool versus the many other forensics/extraction siblings. There is no when-not guidance and no named alternative, leaving selection entirely to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one genuinely non-obvious trait — that an unfiltered call returns only counts rather than the catalog — which is valuable. However it says nothing about the effect of missing_only, registered_only, or include_contracts, nor about permissions or result size limits.

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

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

Two sentences, zero filler. The capability statement is front-loaded and the include_all caution follows immediately; every clause carries 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?

An output schema exists, so return values need not be described. But for a 7-parameter tool with no annotations and no schema descriptions, leaving missing_only, registered_only, and include_contracts entirely unexplained is a real gap an agent must guess around.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It does add real meaning for three inputs — name is exact-match on the `websex_*` pattern, query is substring, category is a facet — plus the semantics of include_all. The three remaining booleans are undocumented in both schema and description, leaving the coverage gap only partly filled.

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

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

States a specific verb and resource ('Search every WebSex executable and native MCP tool') and enumerates the three lookup modes (exact name, substring query, category). Against ~150 sibling execution tools, this is clearly the discovery/meta tool, so an agent can distinguish it 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?

Gives explicit when-to-use guidance for the include_all flag ('only when the complete catalog is genuinely required') and warns that an unfiltered call returns only counts. It stops short of naming alternatives such as websex_recommend_tools or websex_exploit_search, so routing between discovery tools is left to inference.

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

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

With no annotations, the description carries the full behavioral burden, but it does disclose meaningful traits: argv is passed directly with no shell parsing (implying no injection/escaping concerns) and execution is scoped to the engagement namespace. It omits key operational behavior such as authentication requirements (censys needs API credentials) and rate limits.

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

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

Three tight sentences with the core action front-loaded. Every sentence adds operational detail without padding; only the namespace sentence borders on redundancy with 'engagement_id'.

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

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

An output schema exists, so return values need not be described. For a 4-parameter tool with 0% schema coverage, the description covers invocation mechanics reasonably but leaves stdin undocumented and gives no auth/credential context for the underlying censys binary.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that 'arguments' are argv tokens (not a shell string) and that paths should be relative to the engagement namespace, covering the working_directory/engagement semantics. However, 'stdin' is never addressed and 'engagement_id' is only implied.

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 the exact binary being run ('Run censys'), plus its toolkit context (WebSex enumeration). 'censys' is a distinct resource among the siblings, so it is unlikely to be confused, though the description does not explicitly contrast it with 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 explains how to invoke the tool (argv tokens, no shell parsing, relative paths) but gives no guidance on when to use censys versus other enumeration siblings or what conditions select it. The engagement-namespace note is invocation context, not usage guidance.

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

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

With no annotations, the description carries the full behavioral burden, but it does disclose meaningful execution traits: checkov is invoked with raw argv tokens and no shell parsing (an injection-relevant detail), and it runs scoped to the engagement namespace with relative artifact paths. It does not state side effects, permissions, or whether scan output is persisted, which matters for a 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?

Three tight sentences with the core action front-loaded ('Run checkov...'), followed by execution model and scoping. No padding or repetition, though the engagement-namespace and relative-path clauses could be folded together.

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

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

An output schema exists, so return values need not be described. The description covers the execution model and working-directory behavior, which is the essential context for a CLI-wrapper tool. It still omits preconditions (e.g., whether an engagement must exist first) and stdin handling, leaving gaps for a 4-parameter tool.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly covers three of four parameters: 'argv tokens' maps to arguments, 'engagement namespace' to engagement_id, and 'relative paths for engagement artifacts' to working_directory. The stdin parameter is never addressed, and no format or semantics are given for any of them.

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

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

States a specific verb and resource: run checkov from the WebSex container IaC toolkit. An agent understands this is an IaC scanning wrapper. However, it does not distinguish itself from sibling IaC/cloud scanners like websex_terrascan, websex_trivy, or websex_prowler, so differentiation is left to 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?

There is no guidance on when to choose checkov over the other IaC scanners (terrascan, trivy, prowler) or what inputs it expects. The line about running from the engagement namespace and using relative paths is operational setup, not a when/when-not directive. Usage must be inferred from the tool name.

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

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

With no annotations, the description carries the disclosure burden, and it does add genuine behavioral context: the container execs checksec directly with argv tokens and never invokes a shell, which tells the agent how arguments are passed. It still omits anything about failure modes, required engagement state, or permission constraints.

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

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

Three short sentences, front-loaded with the core action, and each adds a distinct operational fact. No filler or redundancy.

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

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

An output schema exists so return values are covered, but with zero annotation coverage and four undocumented parameters the description should do more: stdin is unexplained and there is no note on the engagement_id format or how arguments should be shaped. Adequate but with evident gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It implicitly maps 'supplied argv tokens' to arguments, 'engagement namespace' to engagement_id, and 'relative paths' to working_directory, but never names them and says nothing about the stdin parameter.

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

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

States a specific verb (Run) and resource (checksec from the WebSex binary toolkit), which is enough to identify it among the many binary-analysis siblings. It does not explain what checksec verifies (RELRO/canary/NX/PIE) nor explicitly contrast with siblings like websex_file or websex_objdump, but the named tool is distinctive.

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

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

No guidance on when to reach for checksec versus the other binary-analysis tools (ghidra, objdump, strings, file). The only directives given are operational (engagement namespace, relative paths), not selection criteria or preconditions.

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 load and does reasonably well: it discloses the detection method (per-separator echo canaries), the time-based sleep fallback with sampled medians, and the confirmation criteria (canary output or reproducible delay). It does not state intrusiveness, target impact, or auth requirements, but the technique disclosure is substantive.

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 dense sentences are front-loaded with the primary technique and its fallback, with no filler. Efficient, though the telegraphic style assumes reader familiarity with canary/median terminology.

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

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

An output schema exists, so return values need not be explained, but for an 8-parameter active security probe with no annotations and zero schema coverage, the description leaves parameters, engagement scoping, and safety/rate context entirely unaddressed.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and does not. Nothing explains url, parameter, engagement_id, method, body, headers, max_requests, or follow_redirects; the mention of separators and medians is technique, not 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 names a specific vulnerability class ('Command injection') and the probe technique, which distinguishes it from siblings like websex_sqli_probe and websex_ssti_probe. It stops short of an explicit verb+resource framing, but an agent can tell what the tool targets.

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

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

There is no guidance on when to choose this probe over alternatives (e.g. websex_sqli_time_probe, websex_http_request, websex_http_repeater) or prerequisites such as an existing engagement. The detection methodology is described, but that is how it works, not when to use it.

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

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

With no annotations, the description carries the full burden, and it does disclose real behavior: it fires both actual and preflight requests, cycles a ladder of origin types, and classifies based on ACAO reflection combined with credentials. That is meaningful method context, but it omits whether requests are sent to the live target, what the side effects are, and any rate/safety constraints.

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

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

A single dense sentence with the technique front-loaded and no filler. It is terse to the point of being cryptic in places, but every clause carries 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?

An output schema exists, so return values need not be described, but with six parameters at 0% schema coverage and no annotations, the description leaves the invocation surface largely undocumented and gives no safety or prerequisite 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 0% across six parameters, so the schema adds nothing and the description must compensate. It only indirectly touches include_credentials ("classification depends on ACAO reflection WITH credentials") while url, method, headers, body, and engagement_id remain unexplained.

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 technique (CORS origin ladder) and the exact origin classes tested (evil/null/suffix/prefix) on both actual and preflight requests, which is enough to distinguish it from generic request tools like websex_http_request. It is clear but assumes CORS fluency, and it never explicitly names a sibling it replaces.

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

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

There is no statement of when to use this probe versus alternatives such as websex_http_request, websex_csrf_probe, or websex_host_header_probe, and no prerequisites or exclusions. Usage is only implied by the technique described.

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 disclose real behavioral traits: it actively replays a state-changing request cross-origin against a live session and inspects token/SameSite structure, making clear this is an active, potentially side-effectful probe requiring caller-supplied session state. It omits side-effect/rate-limit caveats, keeping it short of a 5.

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

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

A single front-loaded sentence with no filler, leading with the tool's purpose and progressing through the three checks. Dense but every clause earns its place; slightly packed for one 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?

An output schema exists, so return values need no explanation, and the description conveys the core mechanism and the critical session requirement. For a 7-parameter active probe with zero schema coverage and no annotations, though, the description is not complete enough to guide correct invocation of most parameters.

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

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

Schema coverage is 0% across 7 parameters, so the description must compensate and largely does not. Only session_headers is given meaning ('caller supplies session_headers'); url, body, method, headers, content_type, and engagement_id are left entirely undocumented in both schema and 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 names a specific verb/resource (CSRF posture probe) and enumerates its three concrete checks: token anatomy, SameSite cookie posture, and foreign-Origin replay. This clearly distinguishes it from adjacent siblings like cors_probe, ssrf_probe, and access_bypass_probe without needing to open any 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 implies usage context by stating the replay runs 'against a live session (caller supplies session_headers)', which tells the agent a session is a prerequisite. However, it never states when to use this versus cors_probe/race_probe or when it is inapplicable (e.g., no state-changing endpoint), so usage is only implied.

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 usefully discloses that curl runs directly with argv tokens and that shell parsing is never used, plus the engagement namespace scoping. It omits auth requirements, rate limits, and error/failure behavior, leaving notable gaps for a command-execution tool.

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

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

Three compact sentences, front-loaded with the core action, then the execution model, then the working-directory convention. Little waste, though the namespace/path sentence could be tighter.

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

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

An output schema exists, so return values need not be explained. But the description omits the stdin parameter and gives no tool-selection context against its many HTTP siblings, leaving the definition only minimally complete for a 4-parameter execution tool.

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

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

Schema coverage is 0%, so the description must compensate. It conceptually maps 'arguments' (argv tokens), 'engagement_id' (engagement namespace), and 'working_directory' (relative paths), but says nothing about the 'stdin' parameter, so one of four parameters remains undocumented in both schema and 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?

States a specific verb ('Run curl') and resource ('curl'), and clarifies it is the WebSex web toolkit variant. However, it does not differentiate itself from close siblings like websex_http_request or websex_httpie, which an agent must choose between.

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 indication of when to prefer this over websex_http_request, websex_httpie, or websex_bash. The only guidance ('use relative paths for engagement artifacts') is a path convention, not a tool-selection rule, so the agent is left to infer the use case.

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. 'Without inventing intelligence' gestures at returning authoritative, non-hallucinated data but discloses nothing concrete about auth needs, rate limits, or lookup failures/misses for a network-backed NVD call.

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

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

A single front-loaded sentence naming the action and source. The trailing 'without inventing intelligence' clause is colorful but adds little operational 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 simple one-parameter read tool with an output schema covering return values, the description is nearly sufficient. Its main gap is the absence of input format guidance and any behavioral caveats.

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

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

Schema description coverage is 0% for the single required cve_id parameter. The description does not specify the expected format (e.g., CVE-YYYY-NNNN), so it fails to compensate for the schema gap.

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

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

States a specific verb (Retrieve) and resource (a CVE record from NVD), so the agent knows exactly what it returns. It does not explicitly differentiate itself from siblings like websex_exploit_search, though the 'from NVD' scoping hints at an authoritative-source lookup.

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

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

There is no statement of when to use this tool versus alternatives, nor any preconditions or exclusions. The only guidance is the implied 'CVE lookup' purpose derived from the name.

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, but it does disclose genuinely useful behavior: dalfox is executed directly with argv tokens and shell parsing is never used, and it runs from the engagement namespace. These constrain how the agent should build the call. It stops short of describing permissions, output/return behavior, or runtime limits, so it is adequate but incomplete for a mutation-capable scan tool.

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

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

Three tight sentences with the action front-loaded and no filler. Slight deduction because the namespace/path sentence is more mechanical note than essential description, but overall well-sized.

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

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

An output schema exists, so return values needn't be explained, and the argv/no-shell detail covers the invocation model. But the tool's domain role is absent, so an agent cannot confidently choose it over websex_xsser or websex_xss_probe, and two of four parameters remain unexplained.

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

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

Schema description coverage is 0%, so the description must compensate for all four parameters. It only loosely addresses 'arguments' (argv tokens) and 'working_directory' (relative paths for engagement artifacts) and says nothing about 'engagement_id' or 'stdin', leaving half the parameters undocumented in both the schema and 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 names the binary it runs ('dalfox') and its origin (WebSex web toolkit), so the mechanical purpose is clear. However, it never states what dalfox actually does (XSS/parameter scanning), nor distinguishes it from siblings like websex_xsser, websex_xss_probe, or websex_wfuzz. An agent that doesn't already know dalfox must infer its role.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of alternatives, despite a large sibling set containing multiple other XSS-oriented tools. The only usage notes are about the engagement namespace and relative paths, which are invocation mechanics rather than selection 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 behavioral burden, and it does disclose meaningful execution semantics: raw argv tokens with no shell parsing (an injection-relevant trait) and execution from the selected engagement namespace. It omits permissions, resource limits, expected runtime, and output shape, so the disclosure is partial rather than complete.

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 tight sentences with no filler, and the core action plus execution model are front-loaded ahead of the namespace/path caveat. It is appropriately sized, though it spends a sentence on the toolkit framing rather than differentiating 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?

An output schema exists, so return values need not be described, and the execution model is covered. But for a 4-parameter, annotation-free tool sitting among many near-identical scanners, the absence of selection guidance and of `stdin` semantics leaves real gaps.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate. It explains `arguments` as argv tokens and `working_directory` via the relative-path convention, and implies `engagement_id` selects the namespace, but leaves `stdin` completely unexplained and gives no format examples for the argv array.

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 ('Run dirb') and clarifies it executes the well-known directory brute-forcer via argv tokens. It does not, however, distinguish this from the many sibling content-discovery tools (gobuster, ffuf, feroxbuster, dirsearch, wfuzz), so an agent cannot tell from the text alone when dirb is the right 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?

There is no when-to-use or when-not-to-use guidance and no named alternative, despite ~5 direct siblings in the same directory-brute-force category. The engagement-relative-path note is a usage constraint, not a routing rule, so the agent is left to infer selection entirely.

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

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

With no annotations, the description carries the full burden, and it does disclose one meaningful behavioral trait: the container executes dirsearch directly with argv tokens and never invokes a shell. But it says nothing about network impact on the target, rate limits, timeouts, or whether it writes files into the engagement namespace.

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 tight sentences with no filler, and the core identity ('Run dirsearch') is front-loaded. It stays appropriately short for a thin CLI wrapper.

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

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

An output schema exists so return values need not be explained, and the execution model and namespace convention are covered. Still, for an arbitrary-argv wrapper the description omits the typical invocation pattern and any safety framing, leaving moderate gaps.

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

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

Schema description coverage is 0%, so the description must compensate and only partially does. It clarifies that 'arguments' are argv tokens (no shell quoting needed), ties the namespace to 'engagement_id', and explains relative-path handling for 'working_directory', but the 'stdin' parameter is entirely unaddressed.

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

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

States a specific verb and resource ('Run dirsearch') and identifies it as part of the WebSex toolkit. However, it does not differentiate dirsearch from the many sibling content-discovery tools (gobuster, ffuf, feroxbuster, dirb, wfuzz), leaving the agent to infer the distinction from the binary name alone.

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

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

The description gives operational conventions ('runs from the selected engagement namespace', 'use relative paths') but no when-to-use or when-not-to-use guidance relative to the numerous sibling directory-brute-forcing tools. An agent gets no help choosing dirsearch over gobuster or ffuf.

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 it does disclose meaningful traits: argv tokens are passed directly with no shell parsing (headline-and-injection-relevant), execution is scoped to the engagement namespace, and artifact paths are relative. It does not state whether the tool is read-only, whether it makes external network calls, expected runtimes, or how output/failures surface.

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 compact sentences with no filler, front-loaded on what is invoked and how the container executes it. Nothing is redundant, though there is room for one more sentence on scope/alternatives without bloat.

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

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

An output schema exists, so return values need not be explained, and the execution-model and path details are covered. What is missing is the operational context for a 4-parameter recon tool: what the tool actually enumerates and how it relates to the large family of sibling DNS/recon tools.

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

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

Schema description coverage is 0%, so the description must compensate, and it partially does: 'arguments' is characterized as argv tokens, 'working_directory' is implied by the relative-path guidance, and 'engagement_id' maps to the engagement namespace. The 'stdin' parameter is never addressed, and no format or example is given for the argv array.

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 named resource ('Run dnsenum from the WebSex enumeration toolkit'), so an agent knows this executes the dnsenum binary rather than a generic shell. However, it never says what dnsenum accomplishes or distinguishes it from DNS/subdomain siblings like websex_fierce, websex_amass, or websex_subfinder, leaving the agent to supply that knowledge itself.

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 guidance given ('runs from the selected engagement namespace; use relative paths for engagement artifacts') is about invocation mechanics, not about when to choose this tool. There is no mention of when to prefer dnsenum over fierce, amass, subfinder, or theharvester, and no exclusions or prerequisites.

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 usefully discloses behavioral traits: the container executes docker-bench-security 'directly with the supplied argv tokens' and 'shell parsing is never used', which is real execution-model context an agent can't get from the schema. It stops short of stating side effects, whether the run is read-only, or how failures/exit codes surface.

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 tight sentences with the core action front-loaded ('Run docker bench ...') followed by execution detail and operational guidance. No filler, though the namespace/path sentence is slightly low-value relative to the undocumented parameters.

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

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

An output schema exists, so return values need not be described. For a security-benchmark launcher with 2 required and 2 optional parameters at 0% schema coverage, the description covers the execution model but leaves parameter contracts and read-only/side-effect semantics under-specified.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate and largely does not. It obliquely explains 'argv tokens' (arguments) and relative paths for 'engagement artifacts' (working_directory), but leaves stdin and engagement_id completely undocumented as to format or 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 names a specific verb and resource ('Run docker bench', executing 'docker-bench-security') so the agent knows exactly what is invoked. It implicitly distinguishes from the k8s/cloud siblings (kube_bench, trivy, checkov) by calling out the docker-focused benchmark, but never names an alternative explicitly.

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

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

Usage context is implied rather than stated: it explains it runs from 'the selected engagement namespace' and that relative paths should be used for engagement artifacts, which orients the agent. However, there is no explicit when-to-use guidance versus the many scanning siblings (kube_bench, trivy, prowler, scout_suite), and no exclusions.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the container executes dotdotpwn directly with argv tokens and that shell parsing is never used, and that paths are resolved relative to the engagement namespace. It does not describe the actual operation, expected runtime, or any auth/safety profile beyond the no-shell 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?

Three tight sentences with the action front-loaded and no filler. The no-shell and relative-path notes earn their place; nothing is redundant.

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

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

An output schema exists so return values need not be described, but with zero annotations and a 4-param schema at 0% coverage, the description leaves the tool's actual purpose (traversal fuzzing methodology) implicit and doesn't fully compensate for the parameter documentation gap.

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

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

Schema description coverage is 0% across 4 parameters. The description adds meaning for `arguments` ('supplied argv tokens'), `engagement_id` ('selected engagement namespace'), and `working_directory` ('relative paths for engagement artifacts'), but leaves `stdin` unexplained and gives no format or example for argv tokens.

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

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

States a specific verb and resource: 'Run dotdotpwn'. However, it does not explain what dotdotpwn is (a directory/file traversal fuzzer) nor distinguish it from sibling wrappers like websex_traversal_probe or websex_execute, so an agent must already know the tool's 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?

There is no guidance on when to use this tool versus alternatives such as websex_traversal_probe or a generic executor. It mentions running from the engagement namespace and using relative paths, but that is operational context, not a when/when-not/alternative rule.

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 only discloses that the namespace is persistent and that the ID is server-generated; it does not cover permissions, duplicate-name behavior, target semantics, or side effects expected for a create mutation.

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

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

A single front-loaded sentence with no wasted words. The essential action and result are stated immediately.

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

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

For a create mutation with three parameters and zero schema descriptions, the description is too thin. Although an output schema exists, the required inputs and their expected content are left entirely unexplained.

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

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

Schema description coverage is 0%, and the description mentions none of the three parameters (name, targets, objective). It adds no semantic meaning beyond the bare schema property names.

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

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

States a specific verb ('Create') and resource ('persistent engagement namespace'), and adds the return behavior. It clearly differs from list/get/plan siblings by the creation verb, but it does not explicitly name or reference 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?

No when-to-use guidance, prerequisites, or alternatives are given. An agent cannot tell from the description alone when to call this instead of engagement_plan, engagement_get, or workspace 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 behavioral burden. It implies a read ("Return metadata") but says nothing about error behavior for unknown IDs, permission requirements, or whether the engagement is scoped to a workspace/session. An output schema exists, so return format is at least covered elsewhere.

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

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

A single tight sentence with the resource and the singular-scope qualifier front-loaded. No filler.

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

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

For a simple get-by-id tool with an output schema covering return values, the description is minimally sufficient. The gaps are the missing provenance of the ID and the absence of any error/permission behavior, which matter more here because there are no annotations to fall back on.

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

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

Schema description coverage is 0% for the single required engagement_id, so the description must compensate. It does add one meaningful semantic: the ID is "server-generated," signaling the agent cannot construct it and must source it from create/list. It does not describe the ID's format or where to find 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?

States a specific verb ("Return metadata") and resource ("one ... engagement ID"), and the singular "one" implicitly separates it from the plural websex_engagement_list and from websex_engagement_create. It stops short of explicitly naming those siblings, so it lands at 4 rather than 5.

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

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

The description gives no when-to-use guidance, no prerequisites, and no reference to the sibling tools (create/list/plan) that would tell an agent how to obtain an engagement ID. Usage must be inferred 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?

With no annotations, the description carries the full burden. "List" implies a non-mutating read and "persistent" hints at data lifetime, but there is no disclosure of scoping, ordering, authentication, or whether all engagements are returned. Minimal behavioral context.

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

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

A single front-loaded sentence with no wasted text. The trailing clause "available for client-side selection" is slightly jargon-heavy but does add some orientation.

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

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

An output schema exists, so return values need no explanation, and with no parameters the input side is trivially complete. What is missing is any usage context relative to sibling engagement tools, leaving the definition adequate but thin for its role in the engagement 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate beyond the schema. Baseline 4 applies for a parameterless tool.

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

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

The description states a specific verb and resource ("List ... WebSex engagements"), which distinguishes it from the singular websex_engagement_get and the write-oriented websex_engagement_create. It is clear but does not explicitly name those siblings, so it falls short of a 5.

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

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

"available for client-side selection" vaguely gestures at a downstream selection workflow but gives no condition for choosing this tool over engagement_get, and no when/when-not guidance. Effectively no actionable 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 behavioral burden, and it discloses almost nothing. It does not say whether a plan is persisted, whether it mutates engagement state, whether the output is a plan document or an execution, what authentication is required, or what happens on an unknown kind/target. The single word 'deterministic' is the only behavioral claim, and it is unexplained.

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?

It is a single short sentence with no filler, which is structurally clean, but the brevity here reflects under-specification rather than economy — nothing in the sentence is wasted, yet almost nothing useful is present either.

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

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

An output schema exists, so return-value documentation is not required, but the definition is still incomplete for a 3-parameter composition tool: two required parameters are undefined, there is no annotation coverage for side effects, and the notion of a 'deterministic plan' is never elaborated. The description leaves the agent unable to call this correctly versus its engagement siblings.

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

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

Schema description coverage is 0% and the description supplies no parameter meaning at all. 'kind' is a required free-form string with no enum and no explanation of its allowed values, 'target' is similarly opaque, and 'objective' defaults to empty with no guidance on its effect. This is the critical gap: the agent cannot construct a valid call from either the schema or 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 states a verb and resource ('Create a ... engagement plan'), which is clearer than the bare name, but 'deterministic WebSex engagement plan' is not defined anywhere, and it does nothing to distinguish this from the sibling websex_engagement_create, websex_engagement_get, or websex_engagement_list tools. An agent cannot tell from this text how this differs from the other engagement tools.

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

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

There is no statement of when to use this tool, no prerequisites, and no mention of the obvious alternatives (websex_engagement_create, websex_attack_chain, websex_recommend_tools) despite the catalog containing several planning-adjacent siblings. The only hint is 'using catalog tool names', which implies a composition step but never says when that is appropriate.

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 it does disclose real behavioral mechanics: the container runs `enum4linux` directly with argv tokens and never uses shell parsing, and execution happens in the selected engagement namespace. That is genuinely useful invocation context. It omits the safety profile entirely (nothing says this is a read-only SMB/NetBIOS recon operation, no auth requirements, no timeout or resource notes), leaving meaningful 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?

Three sentences, front-loaded with the core action, then execution semantics, then path guidance. No filler, though the middle clause about shell parsing could be tightened.

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

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

An output schema exists, so return values need not be explained, and the execution model is covered. What is missing for an enumeration tool is any indication of what enum4linux targets or what argument shapes are expected, plus the safety/read-only profile that annotations would normally supply.

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

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

Schema description coverage is 0% across 4 parameters, so the description must compensate and only partially does. It clarifies that `arguments` are argv tokens passed without shell parsing, implies `working_directory` should be relative, and ties execution to `engagement_id`. The `stdin` parameter is never mentioned in either the schema or 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 states a specific verb and resource: 'Run enum4linux from the WebSex enumeration toolkit.' That is unambiguous and identifies the exact underlying binary. It does not, however, distinguish this tool from the very similar sibling `websex_enum4linux_ng`, so the agent has no textual basis for choosing between the two.

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

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

There is no guidance on when to use enum4linux versus alternatives such as enum4linux_ng, smbmap, netexec, or rpcclient, all of which appear as siblings. The only usage-adjacent statement is 'use relative paths for engagement artifacts,' which is an operational convention, not tool-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?

With no annotations, the description carries the full burden, and it does disclose meaningful execution behavior: argv tokens are passed directly with no shell parsing, and execution is scoped to the engagement namespace. It stops short of stating the operation's read-only/non-destructive nature, target requirements, or expected runtime/rate characteristics.

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

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

Three short sentences, front-loaded with the action and free of filler. The execution-model detail is dense but relevant rather than padding.

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

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

An output schema exists, so return values need no explanation, and the execution model is covered. Still, an agent gets no description of what enum4linux-ng actually enumerates, and three of four parameters are undocumented in both schema and prose.

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

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

Schema description coverage is 0% across four parameters, so the description must compensate. It clarifies that 'arguments' are raw argv tokens for enum4linux-ng, but says nothing about 'stdin', 'working_directory', or how 'engagement_id' selects the namespace beyond a passing mention.

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

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

States a specific verb and resource ('Run enum4linux ng'), and the '-ng' qualifier implicitly distinguishes it from the sibling websex_enum4linux. However, it never explicitly contrasts the two variants or says when the ng rewrite is preferred, so differentiation is left to inference.

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 only usage guidance is operational ('runs from the selected engagement namespace; use relative paths for engagement artifacts'). There is no statement of when to reach for enum4linux-ng versus websex_enum4linux, smbmap, rpcclient, or netexec, nor any prerequisite or target 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 provided, the description carries the full burden, and it does add meaningful behavior: argv token passing with no shell parsing, namespace scoping, and relative-path expectations. It omits whether the tool opens an interactive WinRM session, auth requirements, and any destructive/rate-limit traits.

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 compact sentences with the core action (running evil-winrm) front-loaded, followed by the safety-relevant execution model and the path/namespace guidance. Little waste, though the relative-path sentence is somewhat buried.

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

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

An output schema exists so return values need not be described, and the execution model is reasonably covered. The gaps are the absence of any selection guidance against overlapping executor siblings and the undocumented stdin parameter, which leaves the definition only minimally viable.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by explaining 'arguments' as argv tokens, implying the engagement scoping of engagement_id, and implying working_directory via 'use relative paths', but leaves stdin entirely unexplained and gives no format detail for any parameter.

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

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

The description states a clear verb+resource ('Run evil winrm') and names the underlying binary being wrapped, so an agent knows exactly what executes. However, it offers no differentiation from closely related siblings such as websex_execute, websex_bash, or websex_netexec, which also run remote/attack tooling.

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

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

There is no explicit when-to-use guidance and no named alternatives, even though several sibling tools (websex_execute, websex_bash, websex_netexec) overlap in function. The only contextual hint is the passing remark about engagement namespace and relative paths, which is about execution environment rather than 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 the full burden. It reveals that it's executable-backed (implies running external binaries), that it relates to engagement artifacts, and that it's a fallback. It doesn't mention security/permission concerns, but for a dispatch tool this is adequate. The advice 'Use relative paths for engagement artifacts' adds practical context.

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