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

Annotations already supply the read-only and non-destructive safety profile. The description adds useful behavioral details beyond that: matching is exact and case-insensitive, and the result is a possibly empty list. This is meaningful operational context.

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

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

The description is compact, well-structured with clear sections, and front-loads the core purpose and usage guidance. Every sentence contributes useful information; the Returns section is concise and clarifies empty-list behavior.

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, read-only tool with an output schema and sibling context, this description is complete: it covers what the tool does, when to use it, parameter semantics, return shape, and empty-result behavior. Nothing needed for correct invocation is missing.

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

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

Schema description coverage is 100%, so the schema already documents the category parameter thoroughly with an example. The description's parameter section essentially repeats that information without adding new semantic detail, meeting but not exceeding the 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 states a specific verb and resource: 'Search for rules in the ruleset by exact category name'. The exact-match and case-insensitive qualifiers clearly distinguish it from fuzzy/partial search siblings like rules_search or rules_find.

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 explicitly tells the agent to use rules_toc first when the exact category names are unknown, providing a clear alternative and condition. It does not, however, contrast with the other rules_search/rules_find/rules_match siblings, so the guidance is slightly incomplete.

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

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

Annotations already declare read-only and non-destructive behavior, and the description adds the case-insensitive exact-match contract and the possibly-empty result list. While error behavior is not covered, the annotation coverage lowers the burden and the added details are meaningful.

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 compact, front-loaded with the core behavior and usage guidance, and organized with Parameters and Returns sections. It mildly duplicates the schema's parameter documentation, but this redundancy is not damaging.

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, read-only lookup with full schema coverage and an output schema, the description provides everything an agent needs: the exact matching behavior, the fallback tool to use, and the return shape. No important context 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 schema describes the sole parameter fully, including an example, so the description largely restates it. However, it adds the important case-insensitive matching detail not present in the schema description, which helps the agent format the section argument correctly.

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 operation ('Search'), the resource ('rules in the ruleset'), and the matching criterion ('exact section name, case-insensitive'). This distinguishes it from siblings like rules_search, rules_find, and rules_by_category, which are broader or category-oriented.

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 explicitly instructs the agent to call rules_toc first when exact section names are unknown, defining a clear selection boundary. This is direct when/when-not guidance rather than leaving the choice to inference.

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

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

Annotations already mark the tool read-only and non-destructive; the description adds substantial behavioral detail: exact case-insensitive filters, document-order results, offset/max_results pagination semantics, total/truncated fields, and the warning that the unfiltered ruleset can exceed a thousand content items. No contradiction with 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 a one-sentence summary and organized into clear Parameters and Returns sections. It is somewhat long and duplicates schema parameter descriptions, but the return-semantics explanation earns its place.

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

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

With zero required parameters and all filters optional, an agent can call this tool correctly and interpret pagination without guesswork. It is complete for invocation, though explicit guidance on how it differs from the many sibling search/filter tools would strengthen it.

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 parameters are already fully documented. The description mostly restates the schema plus a minor 'ste_example' example and pagination note, adding little meaning beyond what the input 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 first sentence states a specific verb and resource: returning content items across rules, with optional scoping and filtering. This clearly distinguishes it from rule-metadata tools like rules_overview or rules_toc, though it does not explicitly name sibling tools.

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

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

The description gives clear context about what the tool does and why pagination matters, but it never says when to prefer this tool over siblings like rules_search or rules_find, nor does it state exclusions or when-not-to-use 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds useful behavioral context: matching is case-insensitive, exact-id scoped, and the result may be empty. This goes beyond the basic safety profile without over-explaining.

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 clearly structured with a short summary, parameter documentation, and return information. It is mostly concise, though the Parameters and Returns sections duplicate information already available in the schema and output 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 simple single-parameter lookup tool, the description covers the key usage scenario, fallback behavior, and result shape. With annotations and an output schema present, nothing essential is missing.

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

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

Schema description coverage is 100%, and the Parameters section essentially restates the schema's description of id_. No additional semantics are provided beyond what the schema already contains, so the baseline score of 3 is appropriate.

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 ('Search') and resource ('rules in the ruleset') with a clear scope ('by exact id'). It differentiates from siblings by naming rules_match and rules_search as alternatives for when exact-id lookup fails.

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 explicitly instructs to 'Use this first when you know the exact rule/recommendation id' and says to fall back to rules_match or rules_search if it returns no items. This gives clear when-to-use and alternative guidance.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral detail beyond this: case-insensitive regex matching, the specific fields searched, and that the result is a list of matching rules. This goes beyond the annotations 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 compact and well-structured: a one-sentence purpose, a useful sibling distinction, then concise Parameters and Returns sections. Every sentence contributes either purpose, usage guidance, or interface context, with no filler.

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

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

For a tool with one parameter, an output schema, and read-only annotations, the description is complete. It explains the search scope, case-insensitivity, the alternative tool, and the return shape. Nothing an agent needs to invoke this tool correctly is missing.

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

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

Schema description coverage is 100%, so the schema already fully documents the single pattern parameter. The description's Parameters section adds no meaning beyond the schema, which matches the baseline expectation of 3: the schema carries the semantic weight.

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 action—'Search for rules in the ruleset using a regular expression'—and clarifies that matching is against both name and summary. It also differentiates itself from rules_search by naming what it does NOT do (full-content search). This gives an agent a clear, unambiguous purpose.

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 says to use rules_search instead when full rule content must be searched, drawing a clear boundary between the two tools. It also implies this tool is appropriate when searching only name and summary is sufficient. This is strong when-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral detail: the tool returns only lightweight summaries with counts/flags rather than content items, omits summaries when brief=true, and returns results in ruleset order. This goes well beyond the safety hints.

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 well-structured with a front-loaded purpose, a usage pointer, a Parameters section, and a Returns section. Every sentence carries useful information, and nothing is redundant padding.

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

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

For a read-only overview tool with four optional parameters and an output schema, the description fully covers purpose, usage context, parameters, return shape, and ordering. An agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description repeats the schema's parameter explanations (case-insensitive, exact section/category, type_ example, brief default) without adding meaning beyond what the input schema already 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 states a specific verb and resource: 'Return a lightweight, per-rule overview of the ruleset.' It also clarifies what the result does NOT contain ('rather than the content items themselves'), which distinguishes it from siblings like rules_find and rules_examples.

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 explicitly says to use this tool 'for a cheap, low-token summary of what rules exist before drilling into rules_find or rules_examples'. This names concrete alternatives and gives a clear condition for choosing this tool over them.

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 carry basic safety hints; the description supplies the operational behavior: regex case-insensitivity, exhaustive field coverage, content_types narrowing behavior, document-order pagination, and the meaning of truncated. An agent can predict exactly what a call returns and how paging works, with no contradiction of the readOnly/destructive hints.

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 longer than average but structured into What/Parameters/Returns and front-loaded with the primary purpose and sibling contrast before any detail. No sentence is filler; the examples earn their place by making the search scope concrete.

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 rich input schema, the provided output schema, and safety annotations, the description covers everything an agent needs to select and invoke this tool: scope, alternatives, parameter meanings, defaults, and pagination/truncation semantics. The Returns section is a bonus since an output schema exists, reinforcing correct usage.

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 already documents all four parameters at 100% coverage, including defaults, regex matching, and content_types behavior, so the description's parameter section mostly restates structured data. It adds only mild usage flavor, such as 'only note or ste_example' and pagination intent, which is not enough to raise it far above the schema 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 first sentence names the exact action and resource ('Full-text search for rules using a regular expression') and the second differentiates it from rules_match by enumerating the fields searched. The scope is explicit: section, category, name, summary, and all content item data.

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 explicitly contrasts with rules_match ('Unlike rules_match, which only looks at name and summary') and gives concrete use cases ('what rule governs passive voice' or 'where does STE100 mention abbreviations'). This tells an agent when the broader search is appropriate and when the sibling is the narrower alternative.

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

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

Annotations already establish read-only safety. The description adds meaningful behavioral detail: distinct grouping, first-seen ordering, and exact section case-insensitive filtering, plus what each returned entry includes. This goes beyond what annotations convey.

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 well-structured with a clear opening sentence, then Parameters and Returns sections. It is reasonably concise, though the parameter explanation duplicates the schema and could be trimmed without loss.

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 optional-parameter tool with an output schema, the description covers purpose, usage context, and return semantics. It provides enough for an agent to call it correctly without additional explanation, and the output schema fills in structural details.

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%, and the description repeats the parameter's case-insensitive exact-section meaning without adding new semantic details. Baseline 3 is appropriate as the schema already fully documents the parameter.

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

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

The description explicitly states the tool returns distinct (section, category) pairs in first-seen order and characterizes it as a table-of-contents outline. This clearly distinguishes it from per-rule sibling tools by noting it gives no per-rule detail.

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 usage context by recommending this tool before drilling into rules_overview, rules_by_section, or rules_by_category. However, it stops short of explicitly saying when not to use it, though the 'without any per-rule detail' phrase implies that limitation.

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 destructiveHint=false, so the safety profile is covered. The description adds a small behavioral detail by specifying the return type (int), but this is also implied by the 'Returns' section. There is no additional context about edge cases, performance, or counting semantics beyond the basic function, so a 3 is appropriate given the annotation coverage.

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

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

The description is compact and front-loaded: the main action appears in the first sentence, the usage guidance is a single clear sentence, and the return type is given in a minimal 'Returns' block. Every sentence earns its place with no redundancy or filler.

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

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

For a simple, parameterless tool with a provided output schema and comprehensive annotations, the description fully covers what an agent needs: what it does, when to use it, and what it returns. No additional information about errors or edge cases is necessary given the tool's simplicity.

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

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

The tool has zero parameters, and the description provides a baseline of 4 per the rubric. The schema coverage is trivially 100% since there are no parameters to describe, and the description does not need to add parameter details. The 'Returns' section adds value by stating the output type, which is not captured in the empty schema.

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

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

The description states a specific verb ('Return') and a clear resource ('total number of entries in the vocabulary'), and explicitly distinguishes itself from the sibling word_list by noting it should be used when only the count is needed. This makes the tool's purpose unambiguous and differentiates it without requiring schema inspection.

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 names the alternative (word_list) and the condition for choosing this tool ('when you only need the count'). This direct routing leaves no ambiguity about when to use word_count over its sibling.

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 destructiveHint=false, so the safety profile is covered externally. The description adds useful behavioral detail: case-insensitive exact matching, the content of returned entries, and the 'possibly empty' result behavior, which is valuable 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 well-structured with clear sections for overview, usage, parameters, and returns. Every sentence contributes useful information, and the most important scoping and routing guidance is front-loaded. No filler or redundancy.

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

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

For a single-parameter lookup tool with an output schema and safety annotations, the description is complete: it defines matching behavior, return contents, fallback routing, and empty-result semantics. Nothing an agent needs to call it correctly is missing.

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

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

Schema coverage is 100%, so the schema already documents the `term` parameter. The description adds meaning by specifying that the match is exact and case-insensitive and that the term can be a word or phrase, which helps an agent know what input is valid.

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

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

States a specific verb and resource: 'Search for a term by exact name (case-insensitive) in the ASD-STE100 Issue 9 vocabulary.' It also names the sibling it is not by saying to use `word_match` with a wildcard when this returns no items, so an agent can tell them apart.

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

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

Explicitly instructs when to use the tool: 'Use this first when you know the exact word.' It also gives the alternative path: 'Use `word_match` with a wildcard if this tool returns no items.' This is clear routing guidance with no ambiguity.

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 destructiveHint=false, covering the safety profile. The description adds valuable behavioral details beyond annotations: case-insensitive matching, per-term independent results, and that unknown/misspelled terms yield an empty `results` list rather than altering the overall structure. It also explains result ordering. This goes beyond mere annotation repetition, though it doesn't discuss any error scenarios or rate limits, which are minor for a read-only batch 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?

The description is efficiently structured: a concise purpose sentence, a note on equivalence and benefit, then clear Parameters and Returns sections. Every sentence adds information without fluff. The key behavioral notes are front-loaded, making it easy to scan.

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

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

For a read-only batch lookup tool with an output schema present, the description covers all necessary operational aspects: what it does, when to use it, how it behaves for edge cases (unknown terms), and the structure of the return. The annotations cover safety, and the description supplies the remaining context an agent needs to invoke it correctly.

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

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

The schema already describes the `terms` parameter as 'The list of terms to look up exactly' (100% coverage). The description adds meaning by clarifying that each term is processed independently, results are per-term, and matching is case-insensitive. This enhances understanding of how the parameter is interpreted, providing value beyond the schema's simple description.

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

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

The description opens with a specific verb-resource pair: 'Search for multiple terms by exact name (case-insensitive) in the ASD-STE100 Issue 9 vocabulary in a single call.' It clearly states the tool's scope (multiple exact terms) and differentiates from the sibling `word_find` by explicitly noting it is equivalent to calling `word_find` once per term but avoids round-trips. This makes the purpose 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 direct usage guidance: it tells the agent to use this tool when multiple terms need to be looked up exactly, instead of calling `word_find` repeatedly. It even names the alternative (`word_find`) and the condition for choosing this tool (multiple terms). This satisfies the requirement for explicit when-to-use guidance.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds useful behavioral context by naming the underlying algorithm (Python difflib.get_close_matches) and warning that 'results may not be obvious,' which helps set expectations for fuzziness and potential surprises.

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 compact and well-structured, with the core purpose in the first sentence, a usage hint in the second, and a clean Parameters/Returns layout. No redundant filler or restatement of the tool name.

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-only fuzzy lookup tool with an output schema, the description provides everything needed: the search behavior, when to use it, parameter meaning, and a note that the result list may be empty. Nothing important 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 schema already documents 'term' at 100% coverage with 'The term to look up.' The description adds meaning by specifying 'word or phrase' and clarifying that the search is approximate, which is important behavioral nuance beyond the bare schema description.

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

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

The description states a specific action — search for a term with sequence-matching — and clearly identifies the resource as vocabulary entries. It also distinguishes itself from the exact-search sibling by describing approximate matching and 'similar' results, so an agent can tell this apart from word_find without inspecting schemas.

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 explicitly says when to use the tool: 'use when find returns nothing and you want suggestions.' This is clear and actionable. It does not explicitly rule out word_match or word_synonym, but the condition and intent are specific enough for a competent agent.

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 destructiveHint=false, and the description aligns with those. It adds substantial behavioral context beyond the annotations: the operation is expensive, the vocabulary holds thousands of entries, and pagination works through offset and max_results with total and truncated fields describing the result set.

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 front-loads the core purpose and usage guidance in the first two sentences, then uses clear headings for Parameters and Returns. The Parameters section is somewhat redundant with the schema, but the structure is scannable and the extra detail about return semantics earns its place.

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

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

For a paginated list operation with an existing output schema, the description covers everything needed: when to use it, when to use an alternative, cost implications, pagination parameters, and the meaning of the returned fields. The max_results upper bound appears only in the schema, but that is acceptable since the schema is part of the tool contract.

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 input schema already fully documents offset and max_results, including defaults and bounds. The description's Parameters section largely restates the schema ('maximum number... to return', 'skip before returning results') without adding meaningful new semantic information. The baseline of 3 applies because the schema does the heavy lifting.

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

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

The description uses a specific verb-resource pair: 'Return all vocabulary entries.' It also differentiates itself from the sibling word_count by directing the agent to use word_count when only the total is needed. The pagination nuance is clarified in the Returns section, so the overall intent is unambiguous.

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

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

The description explicitly states when to use this tool: 'Only use when you need to process the full vocabulary.' It names the alternative tool and the condition for choosing it: 'Use word_count instead if you only need the total.' It also warns that the operation is expensive and returns thousands of entries, giving the agent a clear reason to prefer lighter 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description adds meaningful behavioral context beyond that: results are paginated, broad patterns can match large portions of vocabulary, and the response includes total count and a truncated flag. It also clarifies how offset and max_results affect the returned page.

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 well-structured and front-loaded: a one-sentence purpose, a brief usage note with examples, then compact parameter and return sections. Every sentence earns its place, with no redundant filler.

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

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

For a read-only regex search tool, the description covers the operation, pagination behavior, parameter semantics, and return structure (results, total, truncated). This is sufficient for an agent to invoke the tool correctly without needing further clarification.

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% coverage and fairly clear descriptions, but the tool description adds critical semantics: 'term' is explicitly a regular-expression pattern with an example ('util.*'), rather than just 'The term to look up.' The pagination semantics of offset and max_results are also reinforced in prose.

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 opens with a specific verb and resource: 'Search the vocabulary using a regular expression pattern' and 'Return all entries whose term matches.' This clearly distinguishes word_match from likely siblings like word_fuzzy or word_find by making the regex mechanism explicit.

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 explicitly states when to use the tool: 'Use it to find all words with a common prefix or pattern' and gives concrete regex examples. It does not name alternatives or exclusions, so it stops short of full when-not guidance, but the intended use case is unambiguous.

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 reveals the algorithm (collect WordNet synsets, cross-reference lemmas case-insensitively), scoping (approved and rejected entries included), and result behavior (term excluded, deduplicated, sorted, empty when no synsets). This substantially exceeds the readOnly/destructive flags already in 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?

Structured with a summary, use-case sentence, Parameters, and Returns sections, with no filler. Algorithmic details earn their place because they tell agents exactly what to expect from the call.

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 one documented parameter, an output schema, and annotations covering safety, the description supplies all remaining decision-relevant details: eligibility scope, exclusions, empty results, and ordering. Nothing an agent needs to invoke it correctly appears 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 schema already fully describes the only parameter, term, with 100% coverage, and the description's 'The word to search synonyms for' adds no new meaning beyond the schema. Baseline 3 applies because the schema carries the semantic weight.

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?

Description opens with 'Search for vocabulary entries that are WordNet synonyms of a word,' a specific verb and resource. It further distinguishes the tool by stating it is for finding approved alternatives to non-STE words and by identifying its scope with sibling tools.

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

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

The line 'Use this to find approved alternatives for a non-STE word' directly states when the tool is appropriate. It also names word_find/word_match/word_fuzzy as same-scope operations, but it does not explicitly say when to prefer those alternatives instead.

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