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

With no annotations, the description carries the burden, and it does signal that this returns informational content ('with links', coverage of paid and free offerings) rather than a computed result. It also hints at an escalation/support scope ('enforcement beyond advice'). It stops short of saying the call is side-effect free or describing the response shape, though for a zero-parameter info tool the risk is low.

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: the first front-loads what the tool returns, the second sets the invocation condition. Nothing is redundant, and the usage constraint is placed after the purpose, which is the right ordering.

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

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

For a zero-parameter, no-output-schema informational tool this is close to sufficient. The residual gaps are that 'Bulwark' is never described as the product in question and 'enforcement beyond advice' is opaque jargon an agent may not interpret 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?

The tool takes no parameters, so the baseline is 4; there is nothing about argument syntax the description could usefully add. The parenthetical '(paid and free)' does help the agent frame expectations about the returned content.

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

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

The description states a concrete resource: maker/vendor information, the full ZagAIrot product lineup (paid and free), and links. Among siblings that are all functional security operations (scan_code, lookup_cve, threat_model), this is clearly the only meta/informational tool, so it is distinguishable without opening the schema. Slightly informal phrasing ('Who makes Bulwark') keeps it from being maximally crisp.

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?

'Call only when the user asks about the maker, support, or enforcement beyond advice' gives an explicit trigger plus an implicit exclusion — routine security questions belong in the sibling tools. It does not name a specific alternative to use instead, which is the only missing element.

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 behavioral burden. "Search" implies a safe read of a public catalog and the parenthetical explains what a hit means, but nothing is said about result shape, pagination, or the fact that limit is capped at 50.

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, zero filler, with the catalog scope and its practical implication front-loaded before the parameter guidance. Every clause carries information an agent needs.

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

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

For a simple two-parameter read tool with no output schema and no annotations, the description covers the input side reasonably but omits the meaning and bounds of `limit` and gives no hint of what the results contain. Adequate, not complete.

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

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

Schema coverage is 0%, so the description must compensate. It does well for `query`, enumerating accepted value forms and the special 'recent' token that the schema does not reveal, but `limit` is never mentioned, leaving half the parameters undocumented 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?

States a specific verb (Search) and a precisely scoped resource (CISA's Known Exploited Vulnerabilities catalog), which implicitly separates it from the general-purpose lookup_cve sibling. It does not name that sibling explicitly, 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?

"actively exploited: patch first" signals the situation where this catalog matters, and the query formats (CVE id, vendor, product keyword, 'recent') imply how to drive it. There is no explicit when-not guidance or named alternative such as lookup_cve for non-KEV CVE details.

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 meaningful work: it names the upstream data source (OSV.dev), discloses that coverage includes MAL-* malicious-package advisories as well as CVEs, and warns that an empty result is not proof of legitimacy — an important false-negative caveat. It omits latency/failure behavior for the external call, keeping it below 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?

Two dense sentences, front-loaded with purpose and then the key caveat; the ecosystem enumeration earns its space because the schema has no enum. Mildly terse in places ('for a dependency') where a few more words would remove ambiguity.

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

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

For a 3-parameter query tool with no annotations and no output schema, the definition covers the source and the ecosystem vocabulary but leaves result shape, version-omission semantics, and lookup-failure behavior unaddressed. Adequate to start a call, incomplete for interpreting the answer.

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 supplies the meaningful missing piece — the accepted ecosystem values (PyPI, npm, Go, crates.io, Maven, RubyGems, NuGet, Packagist) — but says nothing about what 'name' means (package vs. module), and leaves 'version' entirely unexplained, including whether omitting it queries all versions.

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 (Query) and resource (OSV.dev vulnerabilities + MAL-* advisories) scoped to 'a dependency', which is clearly distinct from CVE-centric siblings like lookup_cve. It stops short of explicitly naming which sibling to prefer, so the distinction 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?

Usage is implied rather than declared: an agent can infer this is the tool for vetting a dependency before use, and the closing caveat warns against over-reading an empty result. There is no explicit when-to-use versus check_known_exploited or search_security.

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, so the description bears the full behavioral burden. It does disclose that the return is the complete playbook rather than a summary, but omits error behavior for an unknown name, exact-match/case sensitivity, and response size — relevant for a full-content fetch.

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, zero filler, with the core action stated first and the prerequisite second. Nothing could be removed without losing information.

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

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

For a one-parameter read tool with no annotations and no output schema, the definition covers what is returned and how to obtain a valid argument. Only edge-case behavior on lookup failure 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?

The sole parameter has 0% schema description coverage, so the description must compensate. It usefully points to list_skills as the source of valid names, but says nothing about expected format, exact matching, or what a malformed name produces.

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 'Return' plus a concrete resource 'the full playbook for one skill' tells the agent exactly what it gets back, and the singular scope separates it from the plural list_skills. It stops short of 5 because what a 'skill/playbook' contains is left 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?

'Call list_skills first for names' gives an explicit prerequisite and sequencing step, which is the main usage decision for this tool. There is no guidance on when not to use it or on what happens if the caller already knows the name is stale.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a read-only enumeration and discloses the returned field set, but says nothing about ordering, pagination/result limits, or how filtering behaves when a tag matches nothing.

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 zero waste: the core enumeration behavior and returned fields come first, the optional filter second. Nothing is repeated from the schema.

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

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

For a one-optional-parameter read tool with no output schema, the definition is nearly sufficient — it even enumerates the response fields. The remaining gap is behavioral detail around result size and filter matching rather than anything structural.

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 single 'tag' parameter has no schema description, so the description must compensate — and it does, explaining that the filter is optional and giving four concrete example values ('ai', 'web', 'cloud', 'supply-chain'). It stops short of stating match semantics (exact vs. substring, case sensitivity).

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 ('List every security skill') and names the returned fields (name, description, tags), so an agent knows exactly what comes back. It does not explicitly contrast with siblings like get_skill or skills_for_task, leaving that 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?

'Optionally filter by tag' implies the two usage modes (enumerate all vs. narrow by tag), which is a useful hint. However, there is no guidance on when to prefer this over get_skill (single lookup) or skills_for_task, and no exclusions or prerequisites are given.

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 behavioral burden, and it discloses only the provenance (NIST NVD) and the returned field categories. It says nothing about NVD rate limits, latency or timeout behavior, or what happens when a CVE ID is unknown or malformed — material gaps for an external-network lookup.

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 source and return contents are packed into one clause without redundancy.

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

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

For a one-parameter lookup with no output schema, listing the returned sections (description, CVSS, weaknesses, references) is genuinely useful. Missing are failure semantics for invalid or unknown IDs and any note on external-service constraints, which the absence of annotations leaves entirely uncovered.

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

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

Schema description coverage is 0%, but there is only one parameter and its meaning is largely conveyed by the phrase 'a CVE' plus the schema's required CVE-YYYY-NNNN pattern. The description adds no format, case, or validity guidance 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?

States a specific verb (Fetch) and resource (CVE) plus the authoritative source (NIST NVD) and the fields returned. This distinguishes it from siblings like check_known_exploited and check_package_vulns, though it never names 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?

Usage is only implied: the tool name and description make clear it is a by-ID CVE lookup, but there is no explicit statement of when to prefer it over search_security or check_known_exploited, and no prerequisites or exclusions are given.

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 burden. It discloses the useful traits of authority and fast-changing content, but says nothing about what a call actually returns, whether it performs network access, or any latency/rate considerations - gaps that matter for an unannotated 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?

Two short sentences, zero waste, with the identification of the resource front-loaded before the usage trigger. Nothing in it is redundant with the name or schema.

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

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

For a zero-argument tool with no output schema, the description is complete about purpose but underspecified about the return value - it never says whether the agent gets URLs, article titles, or summaries. An agent could still decide to call it, but cannot predict what it will receive.

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; baseline 4 applies. Schema coverage is 100% and no argument semantics are missing.

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 concrete resource: authoritative, regularly updated sources for AI-driven attacks and AI-system security. It is distinguishable from lookup_cve or check_known_exploited by its AI-attack focus and its 'freshness' framing, though it never names those siblings 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?

"Fetch them when freshness matters" gives a clear positive trigger and implicitly contrasts with the built-in knowledge base, which is stale by comparison. There is no explicit when-not condition or named alternative tool, but the selection context is unambiguous for a zero-parameter fetch.

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

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

With no annotations, the description carries the full burden and does well: it discloses the mechanism (regex, hence no semantic understanding), the accuracy profile ('false positives and misses expected'), and the speed trade-off ('Fast'). It omits operational details such as output shape, severity scoring, or the 200k character input cap, which is why it isn't 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?

Two tight sentences: capability first, then the honest limitation caveat. Every clause earns its place — the vulnerability list and the heuristic disclaimer are both load-bearing.

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

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

For a tool with no annotations and no output schema, the description explains what it detects and how much to trust it, but leaves two gaps: it never explains what a scan returns (finding list, severity, line refs?) and never documents its two parameters, one of which is 0%-covered by the schema.

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

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

Schema description coverage is 0% and the description never mentions either parameter. 'Snippet' loosely implies the required `code` argument, but `filename` and the 200,000-character maxLength constraint are completely undocumented in both schema and description, so an agent gets no guidance on what `filename` changes (language detection? path-based context?).

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

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

States a specific verb and resource ('fast regex review of a snippet') and enumerates the vulnerability classes it targets, which makes its purpose unmistakable. The word 'snippet' implicitly separates it from the path-based sibling scan_path, but it never names that sibling explicitly, 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?

Gives clear contextual guidance: it 'complements SAST, never replaces it', which tells the agent this is a supplementary heuristic pass rather than an authoritative audit. It stops short of explicit routing rules — nothing says when to prefer scan_path, secure_coding_checklist, or search_security over 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?

No annotations exist, so the description carries the full burden and does substantial work: it declares read-only, lists exclusions (vendored/build folders, .env files, symlinks), and explains that source lines are hidden by default for secret hygiene. It doesn't cover output shape, error behavior, or how truncation at max_files is signalled.

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

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

Four short sentences, each carrying distinct information: purpose, exclusions, secret-hiding default, and safety profile. The most operationally important constraint (read-only, secrets hidden) is easy to find and nothing is padded.

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 and no output schema, the description covers the safety profile and filtering behavior an agent needs before calling. The remaining gaps—return shape and the role of max_files—are minor but real for a three-parameter tool with zero schema documentation.

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

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

Schema coverage is 0%, so the description must compensate; it does explain the default behavior behind show_source (source lines hidden so secrets are never echoed) and characterizes path as a local folder. max_files is never mentioned, and no defaults or bounds are given for either optional 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 and resource ("Scan a local folder") and differentiates itself from the sibling scan_code by scope (local folder vs. code scan) while reusing its heuristics. It never says what the scan looks for, leaving the agent to infer the purpose from scan_code, which is why this isn't 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 "local folder" framing and the reference to scan_code imply this is the on-disk counterpart to the code scanner, so usage context is reasonably clear. However, there is no explicit when-to-use/when-not statement and no mention of prerequisites such as whether the path must be inside an allowed workspace.

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 results are best-matching skills with matching lines, but says nothing about read-only behavior, matching semantics, ordering, default limit, or maximum results.

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. Its brevity is appropriate, though the same brevity contributes to gaps elsewhere.

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, and 0% schema description coverage, the definition leaves significant gaps. An agent can infer the basic search operation, but must guess at limit defaults, result ordering, matching scope, and usage relative to sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It implies that 'query' is a keyword string, but it does not explain the 'limit' parameter, its bounds, or its default behavior.

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

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

The description states a specific verb and resource: 'keyword search across all skills' and 'returns best-matching skills with matching lines.' This clearly distinguishes it from retrieval-oriented siblings like get_skill or list_skills, though it does not explicitly name alternatives.

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

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

There is no explicit guidance on when to use this tool versus list_skills, skills_for_task, or get_skill. The keyword-search framing implies a use case, but the description does not state exclusions or routing conditions.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it discloses almost nothing. It does not say whether the result is static reference content or computed output, how language/feature interact, or what happens when they are omitted (both parameters are optional). Only the implicit 'this is pre-commit guidance' framing is added.

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?

Extremely short and front-loaded, but the second half is a compressed value dump rather than a sentence, forcing the reader to decode which list maps to which parameter. It is efficient in size but under-structured rather than genuinely concise.

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

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

With no annotations, no output schema, and two undocumented optional parameters, the description should explain what the tool returns and how to combine language and feature. It leaves the agent unable to predict the response shape or the effect of calling with no arguments.

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 neither parameter has an enum, so the description is the only source of value hints — and it does enumerate candidate languages (python, js/ts, go, java, php, c, rust) and features (login, upload, payment, webhook, search, admin, ai-chat, password reset). However, it never labels these as values for the `language` and `feature` parameters, nor explains defaults, optionality, or free-form behavior.

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

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

The phrase "Pre-commit checklist for new code" signals the resource (a checklist) but never states the verb — does it generate, retrieve, or validate against a checklist? The trailing language/feature lists are raw value enumerations with no framing sentence explaining what they select. It is distinguishable from scan_code/scan_path (which scan), but only by 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?

There is no statement of when to use this versus siblings like scan_code, scan_path, skills_for_task, or search_security, nor any prerequisite or exclusion. An agent must guess whether this produces static guidance or performs analysis.

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

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

With no annotations, the description carries the full disclosure burden and provides almost none: it does not say what is returned (names only, paths, descriptions), whether results are ordered, or whether the tool is a pure read. For a low-risk lookup this is not dangerous, but an agent cannot predict the response shape.

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 purpose front-loaded and the value list compact. The telegraphic phrasing ('task_type:') is efficient, though it reads slightly under-specified rather than deliberately terse.

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 single-parameter recommendation lookup with no output schema, it covers input values well and gives a rough sense of the return ('skills to load'). It stops short on return shape and on whether task_type is a closed set, which an agent deciding between this and list_skills would want.

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 schema declares task_type as a bare string with no enum, so the description's enumeration (web, api, mobile, cloud, llm, agent, data, pipeline, org) is the only source of valid values — a substantial add over the schema. It does not clarify whether other values are accepted or what happens on an unrecognized task_type.

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 phrase 'Which skills to load before building something' conveys a recommendation lookup keyed by task type, which separates it from list_skills and get_skill in spirit. However, it names no verb (get/recommend/list) and never states that it returns a curated skill set for the given task_type, so the agent must infer the output.

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?

'before building something' gives a timing cue that implies when to call it, which is genuine usage guidance. It never mentions when NOT to use it or why an agent would pick this over list_skills/get_skill, leaving the sibling routing entirely implicit.

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

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

With no annotations, the description carries the full disclosure burden. It hints at the output shape (a per-element worksheet plus AI threats) but says nothing about whether the tool is read-only, whether it needs an existing design doc, how long or deterministic the output is, or what depth of input it expects. For an analysis tool with zero annotation coverage, that is a real 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?

One compact sentence with the output artifact front-loaded and no filler. Efficient, though the lack of any second sentence is part of why usage and parameter guidance are missing.

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 one-parameter, no-output-schema analysis tool, the description covers what it produces but not how to invoke it well or what the agent gets back in practical terms (per-element table? narrative? findings list?). Adequate skeleton, missing the operational detail an agent would want.

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 single required parameter is undocumented, so the description must compensate. 'For a described feature or system' does signal that system_description should be free-text describing the design under review, but gives no guidance on expected depth, structure, or granularity. 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?

The description names a concrete artifact (STRIDE-per-element worksheet) plus an AI-specific threat layer, applied to a described feature or system. That is specific enough to distinguish it from sibling scanners (scan_code, scan_path) and CVE lookups. It stops short of a 5 because it uses no verb and does not explicitly contrast with the nearest analysis siblings.

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

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

There is no statement of when to reach for this tool versus scan_code, secure_coding_checklist, search_security, or recent_ai_threat_sources. The design-time intent is only inferable from the word 'worksheet'. No prerequisites, no exclusions.

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