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 implies a read-only lookup and discloses pagination via offset/limit and that results can be large, but it does not say how 'query' matches (substring? case-insensitive?), whether query and section combine with AND, or what the default limit of 150 means.

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

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

Front-loaded with the resource description, then a numbered how-to and examples. The emoji-laden formatting and example block add some bulk, but each section serves a purpose and it is easy to scan.

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

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

An output schema exists so return values needn't be described. For a 4-param, zero-annotation browse tool, the description covers all parameters and usage patterns; the remaining gaps are default values and filter-combination semantics.

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, and it largely does: it explains 'query' as technical keyword search with examples, 'section' as a dropdown group with example values, and 'offset'/'limit' as pagination. It omits the default values and the interaction semantics between query and section.

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: tra cứu (look up) the OWASP WSTG v4.2 catalog, with scope quantified (13 sections, 119 tests). It implicitly separates itself from run_wstg_test by being a catalog lookup rather than test execution, but 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?

Three numbered steps plus two worked examples give clear guidance on when to use keyword search vs section filtering vs pagination. It lacks explicit when-not-to-use guidance and does not name alternatives like run_wstg_test for actually executing a test.

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

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

With no annotations, the description carries the full burden. It does disclose meaningful output behavior (SHA-256 verification, OWASP/VRT dual rating, remediation guidance), but it never says whether a file is written to disk or content is returned, whether an existing finding is required, or what happens if finding_id is null.

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 bullet structure front-loads the purpose and each bullet is substantive. Yet the '(Phase 3 Engine)' label and the mojibake-encoded Vietnamese add noise, and the bullets describe report content rather than invocation guidance, so size is spent on the wrong dimension.

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 for a three-parameter tool with zero annotation coverage and zero schema descriptions, the description leaves the invocation model (which parameter triggers which report, side effects) undeclared, which is a material 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 all three parameters, and the description never mentions finding_id, program_id, or target_url. Nothing explains what these optional parameters select or how the enum value 'default-program' behaves, so the gap is entirely uncompensated.

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: it exports a Markdown-format vulnerability report, and explains the report's content (three-layer evidence, dual rating, remediation). It does not differentiate itself from siblings such as inspect_finding_or_evidence or get_pentest_dashboard, so an agent must infer which tool to pick.

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

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

Usage context is implied by 'Phase 3 Engine' and by the destinations listed (HackerOne, Bugcrowd, enterprise handoff). However, no explicit when-not-to-use rule or comparison to sibling tools is provided, leaving selection 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. 'Dashboard' and 'report' imply read-only aggregation, and the scoping rules are explained, but it says nothing about permissions, whether results are live or cached, performance, or explicit absence of side effects.

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

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

The description is structured with a header, numbered instructions, and examples, and the most important information is front-loaded. It is slightly redundant because the title and first sentence repeat the same concept in English and Vietnamese.

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 thoroughly covers the two input parameters and scoping combinations. It would be more complete if it explicitly confirmed read-only behavior and aligned the example program_id with the schema enum.

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, and it does: it explains program_id as selecting a program-wide aggregation, target_url as an optional single-target filter, and the empty-both case as whole-system aggregation. The only weakness is that the example uses program_id='PROG-DVC-QUANGNINH-2026', which is not among the schema enum values ('' and 'default-program').

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

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

The description states a specific resource (Executive Pentest Dashboard) and enumerates exactly what it aggregates: vulnerability severity distribution, WSTG checklist completion percentage, and SHA-256 forensic evidence. This is clearly distinct from the sibling tools, which manage programs, run pipelines/tests, inspect findings, or export reports.

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

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

It gives explicit scoping guidance: choose program_id to aggregate all assets in a program, optionally use target_url to filter to one target, and leave both empty to aggregate the entire system. Examples illustrate common scenarios, but it does not name alternatives or state when not to use this 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 burden. It usefully discloses that it retrieves 100% original data, raw stdout/stderr, and SHA-256 integrity hashes, but it does not explicitly state read-only behavior, permissions/auth needs, side effects, or error behavior.

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

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

The description is front-loaded and structured with sections, but it is verbose for only two parameters. The guidance and example sections repeat the same finding_id/evidence_id information already stated above, so some sentences do not add new 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?

An output schema exists, so return-value details need not be fully duplicated. The description covers both invocation modes and gives examples, making the tool callable, but it leaves gaps around parameter mutual exclusivity and behavior when no ID is supplied.

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 defines both finding_id and evidence_id with concrete meanings and examples. It still omits optionality, integer format, mutual exclusivity, and behavior when both or neither are provided.

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 investigative/retrieval purpose and clearly separates two modes: retrieving finding details (16 OWASP indicators, remediation) versus evidence details (CLI command, raw stdout/stderr, SHA-256 hash). An agent can understand exactly what resource is being inspected without opening the schema.

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

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

It gives explicit usage conditions for each parameter: pass finding_id to see OWASP risk rating details, or evidence_id to extract raw command output and hash, with concrete examples. It does not address alternatives, mutual exclusivity, or what happens if both/neither are supplied, so it stops short of full when/when-not guidance.

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

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

With no annotations, the description carries the full burden and discloses important behavior: delete permanently removes the program and all subordinate assets, create auto-generates a PROG-YYYYMMDD-XXXXXX ID when blank, and authorization_confirmed defaults to true. It does not cover permission requirements or update partiality in depth, but it is substantially transparent for a CRUD tool.

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

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

The description is front-loaded and organized by action and parameter, with examples that clarify usage. It is somewhat long and repeats some guidance through examples, but the structure remains readable and purposeful.

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?

It covers the full CRUD lifecycle, destructive delete behavior, ID generation, authorization confirmation, and the follow-up action for adding targets. An output schema exists, so return values need not be described; remaining gaps are minor, such as exact update semantics and the program_id enum inconsistency.

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 usefully explains all five parameters, including action choices, status enum values, and auto-ID behavior. However, its program_id examples use values like 'PROG-DVC-QUANGNINH-2026' while the schema enum only allows '' and 'default-program', which may mislead invocation.

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

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

The description names a specific resource (Pentest Program) and all lifecycle operations (list/create/update/delete), so its purpose is unambiguous. It also distinguishes the program container from its 1:N asset scope and points to manage_scope_targets for target management.

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 explains how to choose each action, when program_id is required versus auto-generated, and gives concrete examples for list/create/update/delete. It also names the next-step sibling manage_scope_targets, though it does not explicitly state when not to use this tool versus other siblings.

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

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

With no annotations, the description carries the full load and delivers the key hidden behavior: 'set_target' is an upsert whose write silently overwrites existing asset tier and data sensitivity without creating duplicates, and 'remove_target' revokes scope. It omits permission requirements, reversibility of removal, and error behavior, which keeps it from 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?

The summary is front-loaded, then numbered instructions, then worked examples — the ordering is sound and no section is filler. Length is justified for a four-action, five-parameter tool, though emoji headers and a redundant bulleted restatement of the schema add mild noise.

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 action semantics plus multipliers give an agent enough to call it correctly. Gaps remain: it never says which parameters are optional versus conditionally required per action (e.g. target is meaningless for 'list_targets'), and the stated 'dropdown from database' for program_id conflicts with the schema's two-value enum.

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 does: it explains action values, target formats (URL and IP:port examples), all three asset_tier levels with their multipliers, and all four data_sensitivity levels with multipliers. This is meaning the bare enum schema cannot convey.

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

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

The first two lines give a specific verb set and resource: add/upsert, delete, list and verify URLs/Assets within a Program's test scope. The scope ('theo Program') distinguishes it from program management or pipeline execution siblings. No explicit sibling comparison, but the resource is distinct enough to select 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?

Each of the four actions is defined in normal language (upsert, revoke, check, enumerate), and Example 3 states a clear trigger condition — run 'verify' before executing the pipeline. This gives real when-to-use context even though no action is explicitly excluded or contrasted with a sibling 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 burden and does so: it discloses forensic evidence capture (CLI stdout + SHA-256 hash), 16-indicator OWASP risk rating, scan durations (~10-15s quick vs deep with Nmap), parallel execution, and the failure mode 'BLOCKED - TARGET_OUT_OF_SCOPE'. An agent knows the authorization gate, cost profile, and side effects before calling.

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 core purpose, then cleanly structured as numbered steps plus runnable examples. Some formatting noise (emoji headers, bilingual mix) and example redundancy add length, but nothing is truly wasted.

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

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

An output schema exists, so return values need not be explained. The definition covers prerequisites, scope granularity, profile tradeoffs, and the blocking condition — the only omission is what the L1-L4 sensitivity levels mean and how they interact with asset_tier scoring.

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 explains target_url format with examples, program_id's blank-autodetect behavior, all test_scope variants, scan_profile speed tradeoff, and asset_tier's risk multiplier. It leaves data_sensitivity as a bare list of L1-L4 with no meaning attached, which is the one 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+resource ('Master Penetration Testing Pipeline', launches a one-click automated OWASP WSTG v4.2 run) and contrasts with single-test invocation by noting it can run 'tất cả các bài test WSTG khả dụng song song'. It does not explicitly name run_wstg_test as the alternative, so sibling differentiation is implied 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?

Explicitly says when to use it (full/section/objective scope selection), gives two concrete invocation examples, and states the mandatory prerequisite: targets must be authorized via 'manage_scope_targets' beforehand. Alternatives and exclusions are effectively covered.

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 does disclose meaningful behavior (fan-out to four external recon sources, automatic noise filtering, and creation of tagged entry points). It omits equally important traits: runtime/latency of external lookups, rate limits, whether results are persisted or overwritten, and 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 short sentences with the source list front-loaded, which is structurally sound. But the character-encoding corruption and vague trailing clause ('gắn cả các Entry Points khả nghi và Chất Chặn 2') make the second half low-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 explained, and with only two parameters the surface is small. Still, for a tool that triggers external network scans and produces entry-point records, the description says nothing about scope, side effects, or how to choose inputs.

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 does not. Neither program_id nor root_domain is mentioned, nor that both are optional with defaults (including a surprising enum containing an empty string). The agent gets no hint that root_domain bounds the scan scope.

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 text does name a concrete activity — multi-source attack-surface reconnaissance via crt.sh, subfinder, dnsrecon and httpx — plus a post-processing step that tags entry points. However, the mojibake encoding and unexplained internal jargon ('Chất Chặn 2') make it hard to read, and nothing distinguishes it from siblings like run_pentest_pipeline or triage_surface_entry_points.

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

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

There is no statement of when to call this versus the pipeline or triage sibling tools, no prerequisites, and no exclusions. The agent must infer that this is the enumeration stage that feeds triage_surface_entry_points.

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 this is an active scan against a live target requiring prior authorization, and that the tool can re-run an existing check, but it says nothing about rate limits, timeouts, whether results are persisted as findings, or side effects on the target.

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

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

Purpose is front-loaded in the first line, followed by an ordered parameter guide, a single example, and a closing security constraint. The emoji section headers and the example (which only restates two params already explained) add some noise, but the overall length is justified by the 0% schema coverage.

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 four parameters are all covered. The remaining gaps are the two unlisted enum codes and the lack of guidance on how this differs from the pipeline/catalog siblings, but nothing essential to correct invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: all four parameters are explained, the wstg_code enum is expanded into human-readable test names, and the data_sensitivity levels are given purpose ('nhân hệ số rủi ro tính Severity'). The enum list is incomplete though — WSTG-INFO-03 and WSTG-INFO-04 exist in the schema but are absent from the description, leaving two valid values 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?

States a specific verb pair ('thực thi hoặc kiểm thử lại' / execute or re-test) on a single, granular resource (one WSTG check code), which is clearly distinguishable from the batch sibling run_pentest_pipeline. It does not, however, explicitly name or contrast itself with browse_wstg_catalog or the pipeline tool, so the differentiation is inferable 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?

Gives an explicit precondition ('Mục tiêu BẮT BUỘC phải được cấp phép trước qua manage_scope_targets'), which tells the agent what to call first, plus a concrete worked example. It stops short of saying when to prefer this single-check dispatcher over run_pentest_pipeline or browse_wstg_catalog, so the routing guidance is incomplete.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key behavioral trait that this is a human approval gate with approve/reject outcomes that gate later scanning, which is valuable. It does not state whether rejections are reversible, what approve_all does to all pending items at once, or whether the action is audited – gaps that matter for a mutation-style gate.

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 short lines with the checkpoint identity front-loaded and the approve/reject capability stated immediately. Nothing is padded, though the garbled character encoding makes the text harder to parse than the length warrants.

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 purpose is legible. But for a three-parameter gating tool with zero annotation coverage and zero schema descriptions, the description leaves too much unspecified: which action to use, what program_id/endpoint_id control, and what happens to pending items after a bulk approval.

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 three parameters, so the description must compensate and it largely does not. The APPROVE/REJECT wording loosely maps to the action enum values, but program_id, endpoint_id, and the distinction between approve_all and approve_id are never mentioned. The enum defaults (e.g. default-program vs. an empty string, and a hard-coded PROG-DVC-QUANGNINH-2026 default) are unexplained and potentially confusing.

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 role ('Human Checkpoint 2'), a specific verb set (view/approve/reject), and a specific resource ('các điểm chạm khả nghi' – suspicious entry points / surface). It also positions the tool in the workflow ('trước khi chạy quét sâu' – before the deep scan), which distinguishes it from the sibling run_surface_recon. The mojibake encoding degrades readability but the intent remains recoverable.

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

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

Usage is implied through the 'before running a deep scan' framing, which tells the agent this gate must precede deeper scanning. However, no sibling tool is named as an alternative, and the description does not say what to do if there are no pending entry points or which action to pick for each situation.

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