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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe, repeatable operations. The description adds useful context by specifying what information is returned (build date, last update check, etc.) and the tool's purpose for verification and freshness checks, which enhances understanding beyond the annotations.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a clear usage guideline. Both sentences are essential, with no wasted words, making it highly efficient and easy to parse.

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

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

Given the tool's simplicity (0 parameters, annotations covering safety, and an output schema present), the description is complete. It explains what the tool does, when to use it, and what information it provides, without needing to detail return values since the output schema handles that.

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

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

With 0 parameters and 100% schema description coverage, the schema fully documents the absence of inputs. The description appropriately does not add parameter details, maintaining focus on the tool's purpose and usage, which aligns with the baseline expectation for no-parameter tools.

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

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

The description clearly states the specific action ('show') and resource ('current NIST metadata index status'), listing concrete attributes like build date, last update check, database size, and file path. It distinguishes this tool from siblings by focusing on database status verification rather than data retrieval or updates.

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

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

The description explicitly states when to use this tool: 'to verify the database is available and check data freshness.' This provides clear context for its purpose versus alternatives like data querying or update tools among the 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?

Annotations only indicate readOnlyHint=false, but the description adds valuable context: it specifies the return type ('Returns the file path'), mentions caching behavior ('to local cache'), and clarifies the dependency on get_publication for material_index usage, enhancing understanding beyond basic annotations.

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

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

Two concise sentences front-load key information: the download action and return value, followed by usage guidance for material_index. Every sentence earns its place with 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?

Given the tool's moderate complexity, rich annotations, and the presence of an output schema (which handles return value details), the description is complete enough. It covers purpose, usage context, and behavioral aspects without needing to repeat structured data.

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

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

With 100% schema description coverage, the schema already documents both parameters well. The description adds some meaning by explaining material_index's relation to get_publication output, but does not significantly enhance parameter understanding beyond what the schema provides.

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

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

The description clearly states the action ('Download'), resource ('publication PDF or supplemental material'), and destination ('to local cache'), distinguishing it from siblings like get_document_content or get_publication by focusing on file retrieval rather than content/metadata access.

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

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

It provides clear context for when to use material_index ('to download a specific supplemental file listed in the get_publication output'), but does not explicitly state when not to use it or name alternatives among siblings, leaving some guidance 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe, repeatable read operation. The description adds valuable context beyond annotations: it specifies the scope of data returned ('complete details... statement, guidance, parameters, related controls, baselines, and cross-framework mappings') and clarifies the relationship with enhancements. No contradictions with annotations 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?

The description is efficiently structured in three sentences: first states the core purpose and data scope, second explains the optional parameter, third provides critical usage guidance. Every sentence adds essential information with zero wasted words, and the most important information is front-loaded.

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

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

Given the tool has annotations covering safety (readOnlyHint, idempotentHint), 100% schema description coverage, and an output schema exists, the description provides exactly what's needed: clear purpose, usage boundaries, and additional context about data scope. No gaps remain for an agent to understand when and how to use this tool effectively.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description adds some semantic context: it provides an example for control_id ('e.g. AC-2') and explains the effect of include_enhancements ('to also get all enhancement sub-controls'), but doesn't add significant information beyond what's in the schema. Baseline 3 is appropriate when schema coverage is complete.

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

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

The description clearly states the specific action ('Get complete details') and resource ('a specific SP 800-53 Rev 5 control'), listing the exact information returned. It explicitly distinguishes from sibling tools by stating 'Do NOT use this for searching -- use search_controls to find controls first', making the distinction unambiguous.

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

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

The description provides explicit usage guidance: it specifies when to use this tool ('for a specific control') and when not to use it ('Do NOT use this for searching'), naming the alternative tool ('search_controls'). It also provides guidance on the optional parameter ('Set include_enhancements=True to also get all enhancement sub-controls').

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds valuable behavioral context beyond annotations: it explains the hierarchical browsing behavior (functions → categories → subcategories), includes full-text search capability, and mentions that results include 'count of mapped SP 800-53 controls per entry.' This provides useful operational context that annotations don't cover.

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

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

The description is extremely concise and well-structured. It uses a single paragraph with clear, bullet-like examples that efficiently communicate the tool's behavior. Every sentence earns its place by providing essential usage information without any fluff or repetition.

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

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

Given that annotations cover safety (read-only, idempotent), schema coverage is 100%, and there's an output schema, the description provides exactly what's needed. It explains the hierarchical browsing/search behavior, gives concrete usage examples, and mentions the additional data included (SP 800-53 control counts). No gaps remain for this type of query 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 100%, so the schema already documents all four parameters thoroughly. The description adds some semantic context with usage examples (e.g., 'function="PR" = Protect categories'), but doesn't provide significant additional meaning beyond what's in the schema descriptions. This meets the baseline of 3 when schema coverage is high.

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

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

The description clearly states the tool's purpose: 'Browse/search the NIST CSF 2.0 framework hierarchy.' It specifies the exact resource (NIST CSF 2.0 framework) and the action (browse/search), distinguishing it from siblings like 'get_framework_mappings' or 'search_nist' by focusing specifically on the CSF hierarchy.

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

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

The description provides explicit usage guidelines with examples for different parameter combinations: 'No args = list all 6 functions. function="PR" = Protect categories. category="PR.AC" = subcategories. query="risk" = full-text search.' This clearly indicates when to use specific parameters versus alternatives, though it doesn't name sibling tools explicitly.

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?

Annotations indicate read-only and open-world hints, but the description adds valuable behavioral context: it discloses potential performance ('May take 6+ seconds') and rate-limiting constraints ('due to rate limiting'), which are not covered by annotations. This enhances transparency beyond the structured 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?

The description is front-loaded with the core purpose, followed by usage guidance and behavioral notes. Each sentence serves a distinct purpose (detail listing, usage context, performance warning), with no wasted words, making it highly efficient and well-structured.

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

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

Given the tool's complexity (detailed CVE data), the description is complete: it outlines what information is returned, usage context, and behavioral constraints. With annotations covering safety and an output schema likely detailing return values, no significant gaps remain for agent understanding.

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

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

The input schema has 100% description coverage, clearly documenting the 'cve_id' parameter. The description does not add further semantic details about the parameter beyond what the schema provides, so it meets the baseline for high schema coverage without extra value.

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

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

The description explicitly states the action ('Get full details for a CVE') and lists specific resources returned (description, CVSS scores, affected products, etc.), making the purpose clear and specific. It distinguishes from sibling tools like 'search_cves' by indicating this is for detailed information after searching.

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

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

The description provides explicit guidance on when to use this tool ('Use this after search_cves to get complete vulnerability details'), clearly differentiating it from the sibling 'search_cves' tool. It also mentions an alternative context (rate limiting without an API key), though not a direct alternative 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?

Annotations indicate read-only and open-world hints, but the description adds valuable behavioral context beyond this: it discloses that the operation 'May take 6+ seconds without an NVD API key due to rate limiting,' which informs about potential delays and external dependencies. This is not contradictory to annotations and provides practical usage insight that annotations alone do not cover.

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 with the core purpose in the first sentence, followed by a concise behavioral note. Both sentences earn their place by providing essential information without redundancy, making it efficient and well-structured for quick understanding.

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

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

Given the tool's complexity (simple single-parameter query), high schema coverage, presence of annotations, and an output schema (implied by 'Has output schema: true'), the description is complete enough. It covers purpose, behavioral traits, and performance considerations, leaving detailed return values to the output schema and not overloading the description.

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

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

The input schema has 100% description coverage, with the 'cve_id' parameter well-documented in the schema itself. The description does not add any additional meaning or clarification about parameters beyond what the schema provides, so it meets the baseline score of 3 for high schema coverage without compensating value.

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

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

The description clearly states the specific action ('Get the change history') and resource ('for a CVE'), with explicit details on what the history includes ('when it was modified, what changed (score updates, CPE additions, CWE remaps)'). It distinguishes from sibling tools like 'get_cve' (which likely retrieves current CVE data) by focusing on historical changes rather than static information.

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

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

The description provides clear context for when to use this tool—to retrieve modification history for a specific CVE. It implies an alternative (using 'get_cve' for current data) but does not explicitly name it or state when not to use this tool. No prerequisites or exclusions are mentioned, though the rate-limiting note hints at performance considerations.

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

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

The description adds valuable behavioral context beyond the readOnlyHint annotation. It discloses that 'Results are cached locally' (performance characteristic), handles multiple file formats (PDF, XLSX, etc.), and explains how different parameter combinations affect output (table of contents vs. sections vs. pages). While annotations indicate it's not read-only, the description doesn't contradict this but adds practical implementation details.

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 efficiently structured with two paragraphs: the first explains core functionality and parameter behavior, the second provides usage context and optimization advice. Every sentence adds value - no redundant information or filler. The front-loaded first sentence immediately communicates the tool's primary purpose.

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

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

Given the tool has an output schema (so return values are documented elsewhere), 100% schema coverage, and annotations covering the read/write aspect, the description provides excellent contextual completeness. It covers what the tool does, how parameters affect behavior, supported formats, caching behavior, and practical usage advice for large documents - everything needed to understand when and how to use this tool effectively.

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

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

With 100% schema description coverage, the baseline is 3. The description adds some semantic context by explaining how parameters interact ('Without section/pages, returns table of contents. With section, returns that section. With pages, returns those pages') and provides a concrete example for pages ('e.g., 1-50'), but doesn't significantly expand beyond what the schema already documents about each parameter's purpose.

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

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

The description clearly states the tool retrieves publication content as Markdown, specifies the resource (NIST documents), and distinguishes it from siblings like download_document (which likely downloads files) and get_publication (which likely retrieves metadata). The phrase 'Retrieve publication content as Markdown' provides a specific verb+resource combination with output format details.

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

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

The description provides clear context on when to use this tool ('Use this to read the actual content of NIST documents') and includes practical guidance for large documents. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings (e.g., when to use get_publication instead for metadata).

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?

Annotations already indicate readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds context about 'bidirectional lookup' and references a 'mappings table,' which provides useful behavioral insight beyond annotations. However, it does not disclose additional traits like rate limits, authentication needs, or result format details.

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 highly concise and front-loaded, consisting of two sentences that efficiently convey the tool's purpose and functionality without any wasted words. Every sentence directly contributes to understanding the tool's use case.

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

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

Given the tool's complexity (cross-referencing mappings), rich annotations (readOnlyHint, idempotentHint), 100% schema coverage, and the presence of an output schema, the description is largely complete. It effectively explains the core functionality but could benefit from mentioning output structure or error cases, though the output schema mitigates this 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 100%, with clear descriptions for both parameters (source_id and target_framework). The description adds minimal semantic value beyond the schema, as it does not explain parameter interactions or provide additional context. The baseline score of 3 is appropriate given the high schema coverage.

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

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

The description clearly states the tool's purpose: 'Cross-reference frameworks' with specific examples ('What CSF maps to AC-1?' or 'What 800-53 controls implement PR.AC?') and explicitly mentions it performs 'Bidirectional lookup in the mappings table.' This distinguishes it from sibling tools like get_control or search_controls by focusing on cross-framework mappings rather than individual control details.

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

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

The description provides clear context for when to use this tool: for bidirectional mapping lookups between frameworks. It implies usage through example queries but does not explicitly state when not to use it or name specific alternatives among sibling tools (e.g., get_control for single control 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating a safe, repeatable read operation. The description adds useful context by explaining the 'supersedes chain' behavior, which isn't covered by annotations, but it doesn't detail other traits like error handling or performance. No contradiction with annotations exists.

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 with the core purpose in the first sentence, followed by a usage guideline, with no wasted words. Both sentences earn their place by clarifying the tool's function and when to apply it, making it highly 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?

Given the tool's low complexity (1 parameter, read-only, idempotent), the description is complete enough. It explains the purpose and usage, and with an output schema present, there's no need to detail return values. The annotations cover safety aspects, making the description adequately contextual.

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

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

Schema description coverage is 100%, with the parameter 'publication_id' fully documented in the schema. The description doesn't add any parameter-specific details beyond what the schema provides, such as examples or constraints, so it meets the baseline for high schema coverage without extra value.

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

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

The description clearly states the specific action ('Resolve any publication to its newest available revision') and the resource ('publication'), distinguishing it from siblings like 'get_publication' or 'search_publications' by focusing on revision resolution rather than retrieval or search. The phrase 'Follows the supersedes chain' adds precision about the method.

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

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

The description explicitly states when to use this tool ('Use this when you need the most current version of a document'), providing clear context for its application. It implies an alternative to tools like 'get_publication' by specifying the need for the 'newest available revision' rather than just any version.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds context about what metadata is included (e.g., supersedes chain, supplemental materials), which is useful but does not disclose additional behavioral traits like rate limits, auth needs, or response format details beyond what annotations provide.

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, well-structured sentence that efficiently lists all key metadata components without unnecessary words. It is front-loaded with the main purpose ('Get full metadata') and every part adds value, making it highly concise.

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

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

Given the tool's low complexity (one parameter), rich annotations (readOnlyHint, idempotentHint), and the presence of an output schema, the description is complete enough. It clearly states what the tool does and what metadata to expect, and the output schema will handle return values, so no gaps exist for this retrieval 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 100%, with the parameter 'publication_id' fully documented in the schema (including examples like 'SP.800-53-Rev.-5'). The description does not add any further meaning or details about the parameter beyond what the schema provides, so it meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Get full metadata') and resource ('a specific NIST publication'), listing detailed metadata components (title, abstract, authors, etc.). It distinguishes from sibling tools like 'search_publications' (which searches) and 'get_document_content' (which gets content rather than metadata).

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 context by specifying 'a specific NIST publication' and listing metadata components, suggesting it's for detailed retrieval when you have a publication ID. However, it does not explicitly state when to use it versus alternatives like 'search_publications' or 'get_latest_revision', nor does it mention 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?

Annotations provide readOnlyHint=true and idempotentHint=true, indicating safe, repeatable operations. The description adds value by specifying the return content ('definition, authoritative source, and related terms'), which is not covered by annotations. It doesn't contradict annotations, as 'look up' aligns with read-only 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 with the core purpose, followed by specific usage guidance and return details in just two sentences. Every sentence earns its place by adding critical information without redundancy, making it highly efficient and well-structured.

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

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

Given the tool's moderate complexity, rich annotations (read-only, idempotent), 100% schema coverage, and the presence of an output schema, the description is complete. It covers purpose, usage, and return values adequately, with no gaps for the agent to operate effectively.

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

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

Schema description coverage is 100%, so the schema already documents parameters well. The description adds meaningful context by explaining the semantic difference between 'term' (exact match) and 'query' (keyword search), which clarifies usage beyond the schema's technical descriptions. This compensates for the high baseline.

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

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

The description clearly states the tool's purpose with specific verbs ('Look up') and resources ('NIST cybersecurity/privacy terms'), distinguishing it from siblings by focusing on glossary terms rather than controls, documents, or databases. It specifies the domain (NIST cybersecurity/privacy) and the action (look up terms).

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

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

The description explicitly provides usage guidance: 'Use 'term' for exact match, 'query' for keyword search.' This directly tells the agent when to use each parameter, offering clear alternatives within the tool itself. It distinguishes from siblings by focusing on glossary terms rather than other NIST resources.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context beyond this - it implies searching across a specific domain (NCP security checklists) but doesn't describe pagination behavior (though limit/offset parameters exist), rate limits, authentication needs, or what happens with partial/null parameters.

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

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

The description is extremely concise - just two sentences with zero waste. The first sentence states the core purpose, and the second provides concrete examples that help illustrate usage. Every word earns its place without redundancy.

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

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

Given that annotations cover safety (readOnly, idempotent), schema covers most parameters (67%), and an output schema exists (so return values are documented elsewhere), the description is reasonably complete for its purpose. It clearly identifies the search domain and provides helpful examples, though it could better explain the tool's scope relative to 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 67% (4 of 6 parameters have descriptions), providing a solid baseline. The description adds no parameter-specific information beyond the examples that loosely relate to 'product' and 'authority' parameters. It doesn't explain parameter interactions, search precedence, or how the 'query' parameter differs from specific field filters.

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

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

The description clearly states the tool searches for 'NCP security configuration checklists' with specific examples ('SCAP checklists for Windows Server 2022' or 'CIS benchmarks for Ubuntu'). It specifies the resource (checklists) and provides concrete examples, but doesn't explicitly differentiate from sibling tools like 'search_controls' or 'search_cves' that also search different security resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_controls' or 'search_cves' that might be relevant for different security searches, nor does it provide context about when this specific checklist search is appropriate versus other search operations.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe, repeatable operations. The description adds context about searching validated modules but doesn't disclose additional behavioral traits like rate limits, authentication needs, or what constitutes a match (e.g., substring vs exact). No contradiction with annotations exists.

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

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

The description is two sentences with zero waste: the first states the purpose, and the second provides concrete example queries that illustrate usage. It's front-loaded and efficiently structured without unnecessary elaboration.

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

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

Given the tool has annotations (readOnlyHint, idempotentHint), an output schema exists, and schema coverage is 71%, the description is reasonably complete. It covers the core purpose and usage examples but could benefit from more explicit guidance on alternatives or behavioral details like pagination (implied by limit/offset 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 description coverage is 71%, providing good documentation for parameters like vendor, module_name, and algorithm. The description doesn't add parameter details beyond the schema, but the examples hint at usage (e.g., 'OpenSSL' for vendor/module, 'AES-256-GCM' for algorithm). Baseline 3 is appropriate given the schema does most of the work.

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

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

The description clearly states the tool searches for 'FIPS 140-2/3 validated cryptographic modules' with specific example queries that illustrate its function. It distinguishes itself from siblings like search_cves or search_controls by focusing on cryptographic modules rather than vulnerabilities or controls.

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

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

The description provides implied usage through example queries ('Is OpenSSL FIPS validated?' or 'Which modules support AES-256-GCM at Level 2?'), which suggest when to use this tool. However, it lacks explicit guidance on when to choose this over other search tools like search_cves or search_controls, and doesn't mention prerequisites or exclusions.

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

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

The annotations already declare readOnlyHint=true and idempotentHint=true, covering safety and idempotency. The description adds valuable behavioral context beyond annotations: it explains the three detail levels (summary, standard, full) with token estimates, describes flexible ID format handling, and mentions the ability to include withdrawn controls. No contradiction with annotations exists.

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 efficiently structured with zero waste: the first sentence states the purpose, the second explains ID flexibility, the next three lines detail output levels, and the final sentence provides sibling differentiation. Every sentence adds value.

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

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

Given the tool's complexity (7 parameters, search functionality) and the presence of both annotations and an output schema, the description is complete: it covers purpose, usage guidelines, behavioral details about output levels, parameter semantics for detail_level, and sibling differentiation. The output schema handles return values, so the description appropriately focuses on contextual information.

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

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

With 71% schema description coverage, the description compensates well by explaining the semantic meaning of the 'detail_level' parameter (summary, standard, full) with token estimates, which the schema only lists as options. It also clarifies ID format flexibility, adding context beyond the schema's parameter descriptions.

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

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

The description clearly states the tool searches NIST SP 800-53 Rev 5 security and privacy controls by keyword, family, or baseline, with specific examples of flexible ID formats. It distinguishes itself from the sibling 'get_control' tool by mentioning that tool provides complete detail for a specific control.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: it states 'Use get_control for the complete detail of a specific control including enhancements,' clearly differentiating from the sibling tool. It also implies usage context through the detail level explanations.

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?

Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safe read operations with open-ended queries. The description adds valuable behavioral context about potential 6+ second delays due to rate limiting without an API key, which goes beyond what annotations provide. This helps the agent anticipate performance 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?

The description is appropriately concise with two sentences. The first sentence states the purpose clearly, and the second adds important behavioral context about performance. Both sentences earn their place, though it could be slightly more front-loaded by mentioning the rate limiting earlier.

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

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

Given the tool has annotations (readOnlyHint, openWorldHint) and an output schema exists, the description provides adequate context. It covers the purpose and key behavioral constraint (rate limiting). For a search tool with good annotations and output schema, this is reasonably complete, though it could benefit from more usage 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 50% (two of four parameters have descriptions). The tool description adds no parameter-specific information beyond what's in the schema. With moderate schema coverage, the baseline is 3 since the description doesn't compensate for the coverage gap but also doesn't detract from what the schema provides.

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

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

The description clearly states the tool searches the NVD CPE database for products and platforms, providing a specific verb ('search') and resource ('NVD CPE database'). However, it doesn't explicitly differentiate from sibling tools like 'search_cves' or 'search_controls' that also search different NVD databases, missing full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions rate limiting with/without an API key, but this is behavioral context rather than usage guidelines. There's no mention of when to choose this over other search tools like 'search_cves' or what specific scenarios warrant CPE searches.

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

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

The description adds valuable behavioral context beyond annotations: it discloses performance characteristics ('May take 6+ seconds'), rate limiting implications ('due to rate limiting'), and a specific filter behavior ('Set has_kev=True for only CISA Known Exploited Vulnerabilities'). Annotations cover read-only and open-world aspects, but the description enhances this with practical 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?

The description is efficiently structured in three sentences: the first states purpose and filters, the second specifies a key parameter behavior, and the third covers performance and rate limits. Every sentence adds value with zero waste, making it front-loaded and concise.

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

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

Given the tool's complexity (9 parameters, read-only/open-world annotations, and an output schema), the description is complete. It covers purpose, usage context, behavioral traits, and performance constraints. With an output schema present, it doesn't need to explain return values, and it adequately supplements the structured data.

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

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

With 78% schema description coverage, the schema already documents most parameters well. The description mentions the filter types (keyword, severity, CPE, CWE, date, KEV) but doesn't add significant semantic details beyond what's in the schema descriptions. It meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('Search the NVD CVE database') and resources ('CVE database'), and distinguishes it from siblings by specifying the exact type of search (CVE-focused vs. other search tools like search_controls or search_cpes). It goes beyond a simple restatement of the name.

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

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

The description provides clear context for when to use this tool by listing the supported filter types (keyword, severity, CPE, CWE, date range, KEV flag), which helps differentiate it from alternatives. However, it doesn't explicitly state when NOT to use it or name specific sibling tools as alternatives, keeping it at a 4.

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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds minimal behavioral context with the example query but doesn't disclose rate limits, authentication needs, or what the search returns beyond the schema. It doesn't contradict annotations, but adds little value beyond them.

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

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

The description is extremely concise—two short sentences with zero waste. It's front-loaded with the core purpose and includes a helpful example. Every word earns its place, making it easy to parse quickly.

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

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

Given the tool has annotations (readOnly, idempotent) and an output schema exists, the description is reasonably complete for a search tool. It specifies the resource (NICE Framework work roles) and provides an example, though it could better explain the search scope or result format. The presence of structured data reduces the burden on the description.

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 67% (2 of 3 parameters have descriptions). The description doesn't add any parameter semantics beyond what's in the schema—it mentions 'incident response' as an example but doesn't explain parameter interactions or constraints. With moderate schema coverage, the baseline 3 is appropriate as the description doesn't compensate for gaps.

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

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

The description clearly states the tool searches NICE Framework work roles with a specific example query. It uses the verb 'search' with the resource 'NICE Framework work roles', making the purpose explicit. However, it doesn't differentiate from sibling tools like search_controls or search_cves beyond mentioning the NICE Framework.

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

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

The description provides no guidance on when to use this tool versus alternatives. It gives an example query but doesn't mention when to choose this over other search tools (like search_controls or search_cves) or when not to use it. There are no prerequisites or contextual usage instructions.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations indicate read-only and idempotent operations, the description reveals that this is a broad search tool that returns results grouped by type across multiple NIST data sources. It doesn't contradict annotations (which correctly describe a safe read operation), but provides important operational context about result organization and scope.

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 efficiently structured with three focused sentences: first states what the tool does, second provides usage guidelines, third clarifies scope options. Every sentence adds value, there's no redundancy, and key information is front-loaded. The scope list is presented cleanly without unnecessary elaboration.

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

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

Given the tool's complexity (searching across multiple NIST data types), the description provides complete context about purpose, usage guidelines, and scope options. With annotations covering safety aspects and an output schema presumably handling return values, the description focuses appropriately on what's not captured elsewhere - the broad search capability and when to use it versus targeted alternatives.

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

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

The description adds meaningful context about the 'scope' parameter by listing all possible data types (publications, controls, csf, glossary, cmvp, checklists, nice) in a clear, accessible format. With 67% schema description coverage (2 of 3 parameters have descriptions), the description compensates well by providing this enumeration of scope options that helps users understand what 'scope' controls.

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

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

The description clearly states the tool searches across ALL NIST data types (publications, SP 800-53 controls, CSF framework, glossary, CMVP modules, checklists, and NICE roles) and specifies that results are grouped by type. It uses specific verbs ('search across') and resources, and explicitly distinguishes this from sibling tools by naming domain-specific alternatives like search_publications and search_controls.

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

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

The description provides explicit guidance on when to use this tool ('as a starting point when you're not sure which specific tool to use') and when to use alternatives ('For targeted searches, use domain-specific tools'). It names specific sibling tools as alternatives, making the usage context very clear.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the agent knows this is a safe, repeatable read operation. The description adds valuable behavioral context: 'Default shows only the latest revision of each document' and specifies the return format 'Returns matching publications with ID, title, date, and series.' This goes beyond what annotations provide without contradicting them.

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 efficiently structured with three sentences that each serve distinct purposes: stating the tool's function, specifying return format and alternative tool, and providing exclusion guidance. There is zero wasted text, and the most critical information (what the tool does) appears first.

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

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

Given the tool has comprehensive annotations (readOnlyHint, idempotentHint), 100% schema description coverage, and an output schema exists, the description provides complete contextual information. It covers purpose, usage guidelines, behavioral context, and sibling tool differentiation without needing to explain parameters or return values that are already documented elsewhere.

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

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

Schema description coverage is 100%, so the schema already fully documents all 8 parameters. The description mentions 'Default shows only the latest revision of each document' which aligns with the latest_only parameter's default value, but doesn't add significant semantic value beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Search NIST publications by keyword across all series' with specific series listed (SP 800, SP 1800, FIPS, IR, CSWP, AI). It distinguishes from siblings by explicitly mentioning get_publication for full details and search_controls for SP 800-53 security controls, providing clear differentiation.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: 'Use get_publication for full details on a specific publication' and 'Do NOT use this for SP 800-53 security controls -- use search_controls instead.' This gives clear when-to-use and when-not-to-use instructions with named alternatives.

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

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

The description adds valuable behavioral context beyond the annotations. While annotations only indicate this is not read-only, the description reveals this is a potentially time-consuming operation ('Takes about 5-10 seconds'), involves downloading from external sources, and rebuilds an index. This helps the agent understand the impact and scope of the operation.

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 perfectly structured with three sentences that each earn their place: the core action, timing information, and usage guidance. There's zero wasted text, and the most important information (what the tool does) comes first.

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

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

Given that this is a parameterless tool with an output schema (so return values are documented elsewhere) and annotations covering the read/write aspect, the description provides exactly what's needed: clear purpose, timing expectations, and usage guidance. It's complete for this tool's complexity level.

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

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

With 0 parameters and 100% schema description coverage, the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the tool's purpose and behavior, which is the correct approach 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 clearly states the specific action ('Rebuild the NIST metadata index'), the resource involved ('NIST metadata index'), and the method ('by downloading fresh data from NIST sources'). It distinguishes this tool from its siblings by focusing on index rebuilding rather than querying or retrieving specific data items.

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

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

The description explicitly states when to use this tool ('Use this if you need the most current publication or control data') and provides timing context ('Takes about 5-10 seconds'). This gives clear guidance about when this tool is appropriate versus the many query/search sibling tools.

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