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

Discloses key behavioral traits: writes overlay file, persists map on first run, handles stale maps, and mutual exclusivity of inputs. Annotations are minimal (readOnlyHint=false, etc.), so the description adds significant value beyond them. No contradiction.

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?

Description is relatively long but well-structured: purpose first, then phrasings, then parameter details. Every sentence adds value. Could be slightly more concise, but front-loaded with core output and efficiently organized.

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?

Despite no output schema, describes the output components (likely tests, risk surface, etc.) and edge cases (stale map, first-run, probable_mapping_gap). Provides a complete picture of what the tool does and returns, sufficient for an AI agent to understand usage and outcomes.

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?

Input schema has 0% description coverage, but the tool description thoroughly explains each parameter: root, changed_files, base_ref, artifact_path, write_overlay. It clarifies defaults, mutual exclusivity, and behavior (e.g., artifact path fallback, first-run persistence). This fully compensates for missing schema 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?

Clearly states the tool maps changed files to tests and reports risk surface, likely tests, etc. Uses specific verbs and resources, and lists common user phrasings, distinguishing it from sibling tools like 'sumo_qa_query_repo_map'.

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

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

Provides clear context on when to use (analyze diff impact, find test coverage). Explains the two input modes (changed_files or base_ref) and relationship. Does not explicitly mention when not to use or contrast with alternatives, but the natural language mappings serve as good usage cues.

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

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

No annotations provided; description implies it is a read-only retrieval (citing from catalogue) but does not explicitly state non-destructive behavior or other traits.

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

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

Concise three-line description with front-loaded directive, 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?

Sufficient for a no-parameter, no-output-schema tool; references catalogue which is known from sibling tools, but could mention output format.

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?

No parameters exist, so description does not need to add parameter meaning. Baseline 4 for zero parameters.

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 answers generic testing questions and cites a principle or technique from the catalogue, distinguishing it from more specific QA skills.

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 specifies when to use ('generic testing question not fitting a more specific skill') and implies when not to use, providing clear guidance among many sibling tools.

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

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

Annotations already declare readOnly, non-destructive, idempotent. Description adds that it returns a 'compact map' but doesn't detail exact structure or side effects. No contradictions, and description provides additional context beyond 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 sentences, clear and front-loaded. Every sentence earns its place, 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 no parameters and no output schema, description is fully sufficient. It explains purpose, usage boundaries, and return content. Mentions relevant sibling tools.

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

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

No parameters, so baseline 4. Description does not need to add param info, but it reinforces the read-only nature. No issues.

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 it returns a compact map of core QA workflows with sample prompts, skills, and outcomes. It distinguishes itself from siblings like using_sumo_qa and sumo_qa_deciding_approach by framing itself as a discovery aid.

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 states it does NOT replace the entry router or deciding_approach tool, providing clear when-not-to-use guidance. Also implies it is for discovering capabilities when asking 'what can sumo-qa do?'.

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 are sparse (readOnlyHint=false, etc.), but the description adds extensive behavioral context: memory is advisory, not automatic; sensitive input is rejected; storage location is specified; and memory-derived probes must be cited separately. 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 thorough but well-structured with clear sections for each action, constraints, and examples. It is front-loaded with a concise purpose statement. A slight reduction because it is longer than necessary, but every sentence provides value.

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

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

For a CRUD-like tool with no output schema, the description fully covers all operations, including what list returns (stored lessons), error cases (unrecognized scope), and safety constraints. It is complete for an AI agent to use 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 has 0% description coverage, so the description fully compensates by explaining each action's required fields: capture requires entry with specific subfields; update requires entry_id plus entry; delete needs entry_id; list defaults. It also explains the scope parameter defaults and behavior.

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

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

The description clearly states the tool manages an explicit, user-confirmed review-feedback memory of recurring QA findings. It lists four actions (capture, update, delete, list) and distinguishes this tool from sibling tools by its unique purpose as a memory storage tool for review lessons.

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

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

Provides explicit guidance: never persist without explicit user confirmation, never auto-capture, and lists common natural-language phrasings to help the agent map user intent. It also describes error handling for unrecognized scope and differentiates from other tools by mentioning the shared data-ownership model with risk-ledger and AC tools.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds context that it searches project or global skill locations and returns null if absent, which is 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?

Two short sentences with a clear front-loaded action and return explanation. No unnecessary 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?

For a simple check tool, it covers purpose and return value, but lacks parameter details that would aid correct invocation.

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

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

Despite 0% schema description coverage, the description does not explain the parameters 'skill' or 'scope' beyond their implicit role. The format or allowed values for 'skill' and the meaning of 'scope' are unclear.

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 locates an installed external SKILL.md file and returns the first matching path or null. It distinguishes itself from sibling tools like sumo_qa_install_external_skill or sumo_qa_search_external_skills.

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 use before executing a skill to check installation, but lacks explicit guidance on when not to use it or mention of 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?

With no annotations, the description carries full disclosure burden. It transparently outlines the tool's behavioral loop: failing test → red evidence → minimal fix → green evidence → risk/ledger update. Also notes it pauses when insufficient context/evidence. This gives the agent a good understanding of the process, though it could mention that it modifies code and risk ledger explicitly.

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: starts with usage condition, then workflow summary, then a caveat. It is four sentences, front-loaded. Some redundancy in the examples could be trimmed, but overall every sentence 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?

Given no parameters and no output schema, the description covers the tool's input assumptions (named gap, evidence) and process steps. It implies the output (updated risk ledger, tests, etc.) but does not explicitly state what the tool returns to the agent. A slight gap in specifying return behavior, but sufficient for an experienced agent.

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 no parameters, so the description's role is to clarify what the tool uses from context. It explains that the tool acts on a previously named concrete gap and requires evidence, which is sufficient. No parameter documentation needed.

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

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

The description clearly specifies the tool's purpose: closing a concrete uncovered behavior gap with evidence (failing test -> red evidence -> minimal fix -> green evidence -> update). It distinguishes from siblings by focusing on a single closed loop per gap and pausing when insufficient, which is distinct from other qa tools like measuring coverage or strengthening tests.

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 states the condition for use: after a review, mutation run, or graded scenario has named a concrete uncovered behavior gap. Provides examples of user requests. Implicitly excludes cases without a named gap, and mentions pausing when repo context or evidence is insufficient. Lacks explicit when-not-to-use or alternatives, but context is 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?

With no annotations provided, the description fully discloses behavior: walking user through a step-by-step process (scope → risks → entry criteria → phases → exit criteria → residual risks) with confirmation at each step. It also notes the tool is 'heavier' than another, giving a clear behavioral distinction.

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 three sentences with no wasted words. It front-loads the purpose, then details the process, and ends with a sibling comparison. 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 has no parameters and no output schema, the description covers everything needed: what it does, how it behaves (step-by-step with confirmation), and when to use it over alternatives. It is fully complete for its context.

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

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

The tool has zero parameters, so schema coverage is 100%. According to guidelines, baseline is 4. The description correctly omits parameter details as none exist.

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: creating formal test plans, entry/exit criteria, or phased QA approaches. It explicitly differentiates from the sibling 'sumo-qa-preparing-for-work' by noting this tool is heavier and for tracked/formally reviewed work.

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 (user asks for formal test plan, etc.) and contrasts with a sibling tool. However, it does not list all possible alternatives from the sibling list, leaving some ambiguity about when other tools might be preferred.

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

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

With no annotations provided, the description fully discloses the tool's behavior: loading classifications and approaches, reasoning, picking an approach, routing to sub-skill, and on-demand loading of further catalogues. It does not mention side effects, but the behavior is read-like and well-explained.

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

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

Two sentences, no fluff. The critical 'first step' guidance is front-loaded, and the second sentence provides essential detail on reasoning and routing. Every word 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?

Given the tool's complexity as a router in a QA workflow, the description lacks explicit mention of return values or state changes. Without an output schema, the agent is left to infer what the tool returns after routing. The description is near-complete but missing return semantics.

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

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

The input schema has zero parameters and schema coverage is 100%, so baseline score is 4. The description does not need to add parameter semantics as there are none.

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 it is the first step for any QA intent, loads specific resources (classifications and approaches), reasons over user intent, and routes to the appropriate sub-skill. It distinguishes itself from sibling tools like sumo_qa_load_approaches and sumo_qa_load_classifications by combining loading with reasoning and routing.

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 states 'Use as the FIRST step on any QA intent', providing clear when-to-use guidance. It does not explicitly mention when not to use or list alternatives, but the context of sibling tools suggests specialization.

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, destructiveHint=false, and idempotentHint=true, so the description's statement 'return the execution handoff' aligns. The description adds value by explaining the handoff payload includes 'the skill body plus the original intent', which is useful context beyond the structured 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 concise with two sentences. The first sentence front-loads the core purpose, and the second adds detail about the payload. No redundant 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 absence of output schema and incomplete parameter documentation, the description covers the basic purpose and return value but lacks details on parameter semantics and return format. It is minimally adequate for understanding the main function but not fully complete.

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

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

Schema coverage is 0%, so the description should compensate by explaining the parameters. However, it mentions 'skill body' but does not clarify the meaning of the three parameters (skill, intent, scope). The tool name suggests 'skill' is the file, but intent and scope remain unexplained, leaving a significant gap.

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

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

The description clearly states the tool loads an installed external SKILL.md and returns an execution handoff. The verb 'Load' and resource 'SKILL.md' are specific. However, it does not explicitly differentiate from sibling tools like sumo_qa_load_skill_context, which might also load skill-related 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?

The description implies usage when an external skill is available and needs to be executed, but it lacks explicit guidance on when to use this tool versus alternatives like sumo_qa_check_external_skill_installed. No when-not-to-use or exclusion criteria are provided.

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

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

With no annotations, the description carries full burden. It discloses that tasks run in fresh subagents (parallel where independent), with two-stage review and no per-task check-ins. Adds useful context beyond typical annotations, but lacks details on failure handling or side effects.

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

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

Three sentences: first sets purpose and predecessor, second explains execution mechanism, third notes continuous execution and successor. No fluff, front-loaded with key information.

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

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

For a zero-parameter, no-output-schema tool, the description covers workflow position, execution model, and successor. However, it lacks error handling behavior (e.g., what happens if a subagent or review fails), which would improve completeness.

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?

Input schema has zero properties, so no parameter information needed. The description naturally omits parameter details, and the baseline for zero parameters is 4.

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 it dispatches a QA plan task-by-task after planning, runs subagents with parallel execution and two-stage review, and finishes by routing to a finishing tool. It distinguishes itself from siblings by specifying its position in the workflow (after planning, before finishing).

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

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

Explicitly says 'Use after sumo-qa-planning-qa-rollout' and mentions routing to sumo-qa-finishing-qa-work, giving clear when-to-use context. It does not provide exclusions or alternatives for when not to use, but the sequential workflow implies usage only in that context.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds behavioral detail: it returns entity characteristics, conditions, dependencies, edge cases, and 'what NOT to use' guidance, and states it is domain-neutral. No contradictions 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 well-structured: a concise one-sentence summary, a bullet-like list of outputs, a domain-neutrality note, optional parameter clarification, and example phrasings. It is front-loaded and relevant, though slightly verbose.

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 no output schema, the description explicitly lists what the tool returns (entity characteristics, conditions, dependencies, edge cases, etc.) and covers optional parameters. It fully explains the tool's functionality and output scope, making it complete for its purpose.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains that `environment` and `domain` are optional and 'folded into the analysis', and implies `question` is the main input. This adds some meaning but does not specify exact formats or constraints, which is adequate but not thorough.

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 explains what test data shape and characteristics are needed for a scenario. It lists specific return items. However, it does not explicitly differentiate from sibling tools like sumo_qa_finding_test_data or sumo_qa_validate_test_data, though the purpose is distinct.

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 common natural-language phrasings that map to this tool, giving clear use cases. It does not mention when to avoid using the tool or compare with alternatives, but the examples are helpful for appropriate invocation.

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 thoroughly explains side-effect behavior, file-writing rules, error handling, and the case structure. It goes well beyond the schema and annotations, providing comprehensive behavioral transparency. 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 comprehensive but well-structured, starting with core purpose then detailing case structure and parameters. Every sentence adds value, though it is slightly lengthy. It is front-loaded and organized effectively.

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 (multiple parameters, optional file writing, return structure), the description covers all necessary aspects: input constraints, edge cases, error handling, and return fields. Despite no output schema, return values are explicitly listed. High completeness.

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% schema description coverage, the description fully compensates by exhaustively explaining each parameter: test_cases structure, format enum and constraints, export_title purpose, and output_path file write rules. Adds immense meaning beyond the schema.

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

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

The description explicitly names the verb 'EXPORT' and specifies the resource 'already-structured QA test cases'. It clarifies what the tool does not do (infer or inspect), distinguishing it from other tools in the suite. Purpose is specific and 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 states it is only for plumbing and that the host LLM identifies cases, implying use when cases are already known. While it does not explicitly compare to sibling tools or provide when-not-to-use guidance, the context is clear enough for an agent to understand when to invoke it.

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

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

No annotations are provided, so the description carries the full burden. It only states that it routes between tools but does not disclose how routing works, what happens after routing, or any behavioral traits like authentication needs or result format.

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

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

Two sentences, no wasted words. Front-loads use cases and provides key routing information efficiently.

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 no output schema and zero parameters, the description lacks explanation of what the tool returns or how the routing is presented. An agent needs to know the output format to use the result.

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?

There are zero parameters; baseline is 4. The description does not need to add parameter meaning since there are none.

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 it is a router for test data queries, listing specific scenarios and naming the four sub-tools it routes between. This distinguishes it from sibling tools that are direct executors.

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 'Use when the user asks about test data' and lists example queries, providing clear context. However, it does not mention when not to use it or alternative tools for non-test-data queries.

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 the tool is read-only, non-destructive, idempotent, and not open-world. The description adds useful behavioral context: it reads only the local YAML catalogue (no external lookups) and explains pagination behavior. 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 well-structured: a clear one-sentence summary, followed by return value details, scope limitations, optional filters, pagination instructions, and example phrasings. Every sentence adds value, and the content 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?

The description covers the tool's purpose, input parameters, return structure (ranked matches with confidence, freshness, suitability reasons), pagination fields, and typical use cases. It lacks detailed return field descriptions but is reasonably complete given the complexity and absence of an output schema.

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

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

With only 25% schema coverage, the description partially compensates by explaining the purpose of `scenario_tags` and `known_valid_for` to narrow the search, and describing `offset` and `limit` for pagination. However, parameters like `environment`, `domain`, `product_id`, and `sku` are not mentioned, leaving 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 states clearly that the tool searches the local known-good test data catalogue for scenario matches. It specifies scope ('local YAML catalogue') and differentiates from external lookups, but does not explicitly distinguish it from the sibling tool 'sumo_qa_finding_test_data', which may serve a similar 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 provides good context on when to use the tool, such as narrowing search with optional tags and labels. It also includes pagination information and common natural-language phrasings. However, it does not explicitly state when not to use this tool or mention alternatives, which would improve guidance.

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

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

With no annotations provided, the description carries the full burden and details the tool's actions: runs the suite, captures coverage/risk-to-test map/open follow-ups, writes a markdown summary, and offers to draft a PR description. While it doesn't cover every possible side effect, it provides substantial transparency for an agent.

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 concise yet packed with essential information. It front-loads the usage context and clearly lists all key actions without unnecessary words 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?

The description fully explains what the tool does and what it produces (markdown summary and PR draft), which is complete given there is no output schema. It leaves no ambiguity about the tool's role in the QA workflow.

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

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

The tool has zero parameters, so the description does not need to explain parameters. The baseline for 0 params is 4, and the description adds value by detailing the tool's outputs and workflow beyond the schema.

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

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

The description clearly states the tool's purpose: to finish a QA rollout by capturing evidence, producing a PR-ready summary, and closing the loop. It explicitly mentions preceding actions and distinguishes itself from sibling tools by specifying when it should be used.

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 when to use: 'at the end of a QA rollout (after sumo-qa-executing-qa-rollout, or after a manual multi-step QA task)'. This provides clear context, though it does not explicitly mention when not to use or list 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 indicate read-only and idempotent. The description adds that it never inspects repos, never makes network calls, and explains behaviors with partial bundles, freshness semantics, and sha conflict detection, with no contradictions.

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 front-loaded purpose, followed by constraints, natural-language phrasings, and detailed parameter info. It is slightly verbose but each 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 complexity (nested objects, no output schema), the description covers bundle structure, freshness, conflict detection, and fallback behavior. It notes the output is a compact markdown brief, though finer output details are omitted, which is acceptable.

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

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

Schema description coverage is 0%, but the description thoroughly explains the 'bundle' object structure, including optional fields and 'freshness' semantics. It also details 'local_head_sha' for conflict detection and 'max_files' for bounding, adding significant meaning beyond the schema.

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

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

The description explicitly states the tool validates and renders a context bundle into a markdown brief for QA review/planning, with clear verb and resource. It distinguishes itself from siblings by noting it never inspects repos or makes network calls.

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 common natural-language phrasings and constraints like 'the host gathers the facts'. It implies when not to use (not for data gathering), but does not explicitly list alternative tools for specific cases.

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?

Adds significant behavioral detail beyond annotations: 'infers no risk, invents no numeric score', 'host can never assert ready', structural guarantee on readiness refusal. Annotations already indicate readOnly and idempotent, so description enriches with precise conditions.

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?

Well-structured with bullet points and clear sections. Slightly verbose in places, but every sentence adds value. Appropriate length for complexity.

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?

Covers input semantics, output fields (four-state recommendation, counts, rendered markdown), and behavioral guarantees. Despite no output schema, description fully specifies return values. References to other tools provide necessary context.

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

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

Despite 0% schema description coverage, the description explains each parameter in detail: ledger_rows, context_bundle, coverage, mutation, scope, local_head_sha, max_reasons. Provides semantics, allowed shapes, and behavior when absent.

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 clearly states 'Compose a QA READINESS SCORECARD' and derives a readiness recommendation, with specific verb and resource. It distinguishes from siblings by referencing their output shapes (risk ledger, context bundle) and natural language phrasings mapping to this tool.

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

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

Explicitly says inputs are optional and reuse existing artifacts, and provides common phrasings. Does not explicitly exclude alternatives, but context from siblings and description implies this is the final readiness assessment 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 already indicate read-only, non-destructive, idempotent. Description adds details about bounded output (max_rows), return fields (table, summary, counts, blockers), and clarifies it never infers risks, enhancing transparency beyond 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?

Well-structured with early purpose statement and capitalized emphasis. Thorough but not bloated; every sentence adds value. Slightly verbose given the detailed row specification, but justifiable for complexity.

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?

No output schema present; description covers return fields (table, summary, row count, uncovered blockers) and row structure. Lacks error conditions or input validation, but sufficient for a format-only tool with robust annotations.

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

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

With 0% schema description coverage, the description provides extensive meaning for both parameters: explodes the row object structure (risk_id, risk, source_anchor, test, evidence_status, residual, optional repo_map_node_id) and explains max_rows bounds output. Greatly compensates for schema 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 it validates and renders a risk-to-test traceability ledger as a markdown appendix, distinguishing it from sibling tools by emphasizing format plumbing only, no inference.

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

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

Implicitly suggests use after risk identification via 'FILE/FORMAT PLUMBING ONLY — the host LLM identifies the risks', but no explicit when-not or alternatives among many sibling tools.

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

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

The description discloses that the HTML body never rides back to the host, writing only when write_to is set, and overrides are validated. Annotations are minimal, so the description carries the burden well, though it doesn't mention performance implications.

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

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

The description is well-structured with a summary, natural-language examples, and parameter details, but it is somewhat lengthy and includes redundant explanations (e.g., 'missing data is never reported as passing evidence' is restated).

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

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

The description covers the main use case, parameter behavior, and edge cases like missing artifacts. No output schema exists, but the return value is described as a 'compact readiness summary' with readiness verdict. Could detail the summary format more.

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

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

Schema coverage is 0%, but the description explains each parameter in detail: root as repository path, write_to as optional output path, and the inline override parameters with their shapes and precedence. This adds significant meaning beyond the schema.

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

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

The description clearly states the tool composes .sumo-qa artifacts into a local QA report and returns a readiness summary. The verb 'compose' and mention of specific artifacts distinguish it from siblings like sumo_qa_format_risk_ledger, which handle individual pieces.

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 natural-language phrasings and explains when to use the tool (after artifacts exist). It details optional parameters and precedence, but does not explicitly state when not to use it or compare directly with 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?

No annotations exist, so description carries burden. It outlines the multi-step process with confirmation gates, and discloses critical behavioral constraint (defer writing until agreement). However, lacks details on failure modes or state changes.

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

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

Two sentences, no wasted words. Front-loads sibling dependency. Could be structured with bullets for clarity, but current form is 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 zero parameters and no output schema, description covers usage and process adequately. Lacks mention of return values or next steps, but tool likely yields conversation prompts. Adequate but could be more thorough.

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?

No parameters in schema, so baseline is 4. Description adds no parameter info (unneeded) but provides process context that adds value beyond 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 clearly states this tool implements TDD after a decision from 'sumo-qa-deciding-approach', with a specific process (plan → risk → test idea → confirm → red → hand off → green → review). It distinguishes itself from siblings by specifying it's used only after a TDD approach is chosen.

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

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

Explicitly says 'Use after sumo-qa-deciding-approach picks...', provides example prompts, and warns 'Don't write the test until the test idea has been agreed.' This gives clear context for when and how to use the 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 (all false) are minimal. The description adds value by explaining validation, normalized copy writing, loader precedence, and the unsupported_source result. However, it could detail more about return values beyond error cases.

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?

Well-structured with front-loaded main action, detailed paragraphs, and even natural-language phrasings. Slightly verbose in places (e.g., loader precedence details) but every sentence serves a 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 no output schema and sparse annotations, the description covers all necessary aspects: inputs, behavior, edge cases, and alternative flows. It fully equips the agent to use the tool 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?

With 0% schema coverage, the description fully explains all three parameters: source (path), scope (project vs global with reasoning), and content_type (for non-native conversion). This compensates completely for the missing schema 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 starts with a clear verb+resource statement: 'Adds or replaces team QA knowledge/standards/rules from a local native file.' It specifies accepted file types and distinguishes from non-native sources, making it distinct from sibling tools like load_* which are read-only.

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 states when to use (for native sumo-qa files) and when not to use (PDF/PPTX/URL), directing to an alternative flow via sumo_qa_suggesting_external_skill. Also clarifies scope choice and loader precedence, providing comprehensive 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 indicate readOnlyHint=false and openWorldHint=true. The description adds behavioral context by explaining the confirmed flag 'records that the host received explicit user approval before invoking the install operation', which goes beyond 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?

Two clear, front-loaded sentences with no wasted words efficiently convey the tool's purpose and a key behavioral note.

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

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

The description is adequate given the open-world hint and annotations, but lacks details on success/failure outcomes, side effects, or parameter interactions, which would improve completeness for an install tool.

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

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

Schema description coverage is 0%, so the description must compensate. However, it only mentions the 'confirmed' parameter briefly, leaving four other parameters (skill, source, scope, agent) without any explanation of their meaning.

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

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

The description clearly states 'Install an external agent skill through the Skills CLI', using a specific verb and resource that distinguishes it from siblings like check_external_skill_installed or execute_external_skill.

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

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

It implies usage for installing skills and mentions the 'confirmed' flag for user approval, but does not explicitly state when to use this tool versus alternatives or provide 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?

Beyond annotations (readOnlyHint, idempotentHint), the description adds important behavioral details: local-only, no network/extraction/caching, deterministic, and error handling for unrecognised detail values.

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, but slightly verbose with repeated mentions of skill index arrays. However, every sentence adds value and the organization is logical.

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?

Without an output schema, the description fully describes the return format for both detail options, explains error handling, and provides context for how this tool fits with others (e.g., sumo_qa_load_skill_context).

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

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

Despite 0% schema coverage, the description exhaustively explains the single parameter 'detail' with two options ('compact' and 'full_index'), detailing what each returns, and notes behavior for unrecognised values.

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 it returns deterministic metadata for every bundled skill as a JSON string and clarifies it is a routing/index aid, not skill bodies. This clearly distinguishes its purpose from sibling tools like sumo_qa_load_skill_context.

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

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

The description explains when to use this tool (for routing/index) and provides explicit alternatives: 'Once routing has chosen one skill, fetch that skill's section/module index with sumo_qa_load_skill_context(...)' and mentions that zero-argument skill tools still return full bodies unchanged.

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 tool is safe and idempotent. The description adds value by specifying that output is plain text, which helps set expectations. No contradictions 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?

Two concise sentences with no redundancy. The verb is front-loaded, and every sentence adds value. The description is efficiently 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 zero parameters, annotations, and no output schema, the description is quite complete. It explains what the tool returns and why it is used. A slight improvement could be to define 'canonical QA approaches' or mention related tools, but it's adequate for a simple 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?

The tool has no parameters, and the input schema coverage is 100%. The description does not need to explain parameters, and its focus on the return value is appropriate. It adds meaning beyond the schema by explaining the purpose of the output.

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 that the tool returns canonical QA approaches as plain text. It uses a specific verb ('Return') and identifies the resource ('canonical QA approaches'). While it doesn't explicitly differentiate from siblings like sumo_qa_deciding_approach or other load tools, the purpose is unambiguous.

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

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

The description mentions that the host LLM picks which approach fits a piece of work, implying usage for selecting approaches. However, it lacks explicit guidance on when not to use this tool or alternatives (e.g., sumo_qa_deciding_approach). Usage is implied but not clearly delineated.

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 behavioral details beyond annotations: it is read-only and local-only, never raises errors (returns error envelope), and marks output with canonical flags. This complements the readOnlyHint and idempotentHint annotations without contradiction.

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 bullet points and clear sections, but is slightly verbose. Every sentence adds value, though some redundancy could be trimmed without loss of meaning.

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 three parameters, no output schema, and many sibling tools, the description is thorough: it covers input combinations, output behavior (canonical flags), error handling, and ties to other loaders. The agent has all needed information to invoke 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?

With 0% schema description coverage, the description fully explains each parameter: 'catalogue' must be one of four values, 'name' matches slug or heading text, 'format' has detailed semantics including defaults and canonical marking. This adds essential context missing from the schema.

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

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

The description clearly states it loads a single catalogue entry or whole catalogue as JSON, and distinguishes itself as 'a lighter alternative to the full-text loaders' for four specific prose catalogues. It explicitly names the catalogues and contrasts with sibling zero-argument loaders.

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 when-to-use guidance: use with 'name' for a single entry, omit for whole catalogue; choose 'full' format for safe citation, 'compact' for navigation only. It also notes that the existing zero-argument loaders remain unchanged, helping agents decide between 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 idempotentHint=true. The description adds that it returns plain text and that the host LLM picks applicable classifications, providing context beyond annotations without contradiction.

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

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

Two sentences front-load the purpose and succinctly cover return type and usage. No redundant information.

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

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

For a simple tool with no parameters and no output schema, the description completely covers purpose, return format, and usage context. No gaps.

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

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

No parameters exist, schema coverage is 100%, so the description adds value by explaining the return format and usage, meeting the baseline for zero-param 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 it returns 'canonical change classifications as plain text', with a specific verb and resource. It distinguishes from sibling load_* tools that load other entities like approaches, rules, etc.

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: when the host LLM needs to pick classifications for a change. It doesn't explicitly state when not to use, but the context is clear among 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 already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds minimal behavioral context beyond the usage hint ('cites principles') and does not disclose any additional behavioral traits such as output size or performance implications.

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

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

The description is two sentences, front-loaded with the action, and contains no redundant information. Every word 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?

Given zero parameters, no output schema, and a straightforward purpose, the description adequately explains what the tool returns. However, it could be more complete by specifying the format or length of the output, or by contrasting with similar load tools.

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

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

With zero parameters and 100% schema coverage, the baseline is 4. The description does not need to add parameter information, but it does clarify what the output contains, which is sufficient.

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 returns ISTQB Foundation, Advanced, and ISO 25010 grounding as plain text, using a specific verb 'Return' and resource. It distinguishes from sibling load tools that handle different content types (approaches, classifications, etc.).

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 the tool is used when citing principles in recommendations, but provides no explicit guidance on when to use this versus alternative load tools (e.g., load_standards) or when not to use it.

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

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

Annotations already declare readOnly, idempotent, and non-destructive. The description adds that it returns plain text and that 'no keyword inference' occurs, but could mention default behavior when no filter is applied.

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

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

Two sentences, front-loaded with the main purpose, 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?

For a simple read tool with one optional param, the description covers the main behavior and return format. Minor gap: no mention of what happens if no classification is provided.

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 has 0% coverage for the classification parameter, but the description adds that it accepts 'single or comma-separated values', which is crucial for correct usage.

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 returns 'the team's loaded change rules as plain text' and specifies an optional filter, distinguishing it from sibling tools like sumo_qa_load_classifications.

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

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

The description explains when to use the filter but lacks explicit guidance on when to use this tool versus alternatives or when not to use it.

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

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

Despite annotations already indicating readOnlyHint=true, idempotentHint=true, the description adds significant value: it explains the known_hash change detection mechanism, error handling (never raises, returns JSON error envelope), and guarantees about being local-only and safe across hosts. No contradictions.

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 bullet points for modes and clear separation of concepts. It is slightly lengthy but every sentence adds value, and it is front-loaded with the core 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 complexity (5 parameters, no output schema), the description is thorough: it covers modes, parameter usage, error handling, change detection, and safety. It does not formally describe the response structure but mentions key fields like content_hash and estimated_tokens, which is sufficient for an AI agent.

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

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

Schema description coverage is 0%, but the description fully compensates by detailing the allowed values for mode (manifest, section, module, full) and how section and module parameters correspond to manifest IDs. It also explains known_hash usage. All 5 parameters are meaningfully described.

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 loads a slice of a skill's context as a JSON string, explicitly listing modes (manifest, section, module, full). It distinguishes this from loading the whole SKILL.md body and from sibling tools like sumo_qa_load_approaches.

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

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

The description explains when to use each mode, especially noting that 'full' mode is identical to the existing zero-argument skill tool and that oversize bodies return a pointer to slices. It provides clear context for when to use this tool over 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. The description adds behavioral context: the filter is metadata-based (frontmatter) and returns plain text, which is not 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?

Two concise sentences with no fluff. The most important information (what it returns and the filter behavior) 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?

The description says 'as plain text' but doesn't specify the exact format or if there are size limits. While readOnlyHint ensures safety, more detail on the output structure would improve completeness.

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% schema description coverage, the description fully explains the classification parameter: it accepts comma-separated values, is metadata-based, and does no keyword inference, which is essential for correct usage.

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 specific verb 'Return' and noun 'loaded standards packs as plain text', clearly distinguishing from sibling tools like sumo_qa_load_approaches or sumo_qa_load_classifications which load different content types.

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

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

The description explains the optional classification filter and explicitly states 'no keyword inference', setting clear expectations. While it doesn't explicitly contrast with alternatives, the tool name and context make the use case obvious.

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, destructiveHint, idempotentHint. Description adds that output is plain text and describes usage pattern, which is 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?

Two concise sentences with no wasted words. 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?

For a zero-parameter, read-only tool with rich annotations, the description fully covers purpose and usage context.

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

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

No parameters; baseline 4 as schema coverage is 100% and description doesn't need to add param info.

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 clearly states it returns the test design technique catalogue as plain text, listing example techniques. This distinguishes it from sibling 'load_' tools like load_approaches or load_classifications.

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?

States 'The host LLM picks one technique per named risk', giving context for when to use it. However, no explicit when-not-to-use or alternatives mentioned.

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

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

With no annotations provided, the description bears full burden. It discloses that the tool runs the configured coverage/mutation tool, reads its output, and persists a summary. This is transparent but omits potential failure modes or configuration requirements.

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

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

The description is two sentences long, front-loaded with usage guidance, and every sentence adds distinct value. No redundant or extraneous content.

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 no parameters or output schema, the description adequately covers when and how to use it. It explains the process and artifact location, fitting the complexity of the tool well.

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?

There are no parameters, and the schema coverage is 100%. The description adds value by explaining the tool's actions but does not need to elaborate on parameters. Baseline of 4 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 clearly identifies the verb (runs, reads, persists) and resource (coverage/mutation tool, .sumo-qa artifacts). However, it does not explicitly distinguish itself from sibling tools like sumo_qa_record_coverage and sumo_qa_record_mutation, which may overlap in 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 provides explicit usage context ('Use when the user wants coverage or mutation numbers') and lists example phrases. However, it lacks guidance on when not to use this tool or mention of alternative tools for similar tasks.

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?

Without annotations, the description carries the burden. It explains the step-by-step process ('Walks scope → file structure → bite-sized tasks → confirm, one section per turn') and the output file creation. This provides good behavioral context, though it omits details like whether it modifies existing files or requires specific permissions.

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 concise (3 sentences), front-loaded with the use condition, and every sentence serves a purpose: when to use, what it does, and what the output is. 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 has no parameters, no output schema, and no annotations, the description provides a comprehensive overview: use case, process, output path, and relation to a sibling tool. It could be slightly more explicit about the tool's behavior if the conversation lacks the needed context, but overall it is complete enough for an agent.

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 zero parameters and full schema coverage, the baseline is 4. The description adds value by explaining that the tool expects context from the conversation (the 'chunk of QA work') rather than formal parameters, which is meaningful for the agent.

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 it converts QA work into a written plan of bite-sized tasks, with a specific output file path. It distinguishes itself from sibling tools like sumo_qa_executing_qa_rollout by being the planning step before execution.

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 'Use when you have a chunk of QA work...' and mentions the prerequisite of no test code written. It also notes the file is ready for subagent dispatch via a sibling tool. However, it does not explicitly state when not to use it or list 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 explains the tool produces risk identification and a test proposal. While no annotations are available, the description implies no destructive actions, which is appropriate for a planning tool. A slightly more explicit statement about being non-destructive would enhance transparency.

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

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

Extremely concise: two sentences that front-load the usage scenario and core functionality, 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 no output schema, the description adequately explains what the tool does and its context (pre-coding planning, risk identification, test set proposal). It could note the output format, but it is sufficient for a lightweight analysis 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?

With zero parameters, the description does not need to augment parameter meanings. The baseline for zero parameters is 4, and the description adds value by explaining the tool's context and output.

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: to plan QA for a story/ticket before coding starts, identifying risks and proposing a test set. It distinguishes from the sibling 'sumo-qa-creating-test-plan' by noting it is lighter-weight and lacks formal criteria.

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 tells when to use ('when user asks to plan QA... before coding starts') and contrasts with the heavier sibling tool, providing clear guidance on when not to use this tool.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds significant behavioral details beyond annotations: ranking (exact identity above substring hits), limit behavior (total_matches still reports full count), types restriction, and fallback logic for artifact_path (live scan if missing, ignores wrong project root). This fully discloses operational 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 approximately 150 words, well-organized into paragraphs and a bullet-like list of examples. It is front-loaded with the main purpose and each sentence adds value, with no redundancy or filler. The structure makes 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?

The description covers the tool's purpose, behavior, parameters, and output (metadata fields like id, path, type, tags, match reason). It lacks details on response structure or pagination for large result sets, but the limit parameter and mention of bounded ranked list suffice. Annotations cover safety and idempotency. Overall, it is well-rounded and sufficient for the complexity.

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

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

Schema description coverage is 0%, so the description carries the full burden. It explains all five parameters: root, query (case-insensitive matching across multiple fields), limit (caps matches), types (restricts to node types or 'command'), and artifact_path (default, fallback, and ignore condition). Additionally, it describes default values and behavior, compensating fully for missing schema 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 it searches the repo-map for specific items (components, tests, CI checks, etc.) and returns metadata to open files directly, never the full artifact. It includes natural language examples and distinguishes from potential siblings by specifying the bounded, ranked list output.

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

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

The description provides natural-language phrasings that map to the tool, implying appropriate usage contexts. However, it does not explicitly state when not to use it or compare it to alternatives like sumo_qa_scan_repo, leaving the agent to infer usage boundaries.

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 fully discloses behavioral traits beyond annotations: validation fails before write, coverage is reported not gated, and the tool's role as plumbing. Annotations are all false and consistent with the description.

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 sections (purpose, phrasings, parameter details, behavior) and front-loaded. It is slightly lengthy but 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?

For a 3-parameter tool with nested objects and no output schema, the description is quite complete. It covers inputs, validation behavior, and special cases (omit line_percent). A minor gap is the lack of return value information, but the tool likely has no significant output.

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?

Despite 0% schema description coverage, the description thoroughly explains the 'coverage' dict structure (including optional fields and semantics) and the 'write_to' default and path constraint. 'root' is implied but not deeply detailed.

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 validates and persists a coverage summary as a specific artifact (.sumo-qa/coverage.json). It explicitly distinguishes this as 'plumbing only' and differentiates from siblings by focusing on recording rather than measuring coverage.

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

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

Provides explicit common phrasings mapping to the tool and clarifies what it does not do (runs nothing, infers nothing). However, it does not explicitly list alternatives or when not to use it, though the context is 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 are minimal (readOnlyHint=false, etc.), but the description adds significant behavioral detail: validation occurs before write, evidence is reported not gated, and it runs nothing. 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 the main action, includes common phrasings, and details parameters concisely. Every sentence adds value, and the structure is logical and 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?

The description covers the tool's role, parameter details, and validation behavior. It could mention what happens on validation failure or error cases, but for a plumbing tool with good coverage of inputs, it is sufficiently complete.

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

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

Despite 0% schema coverage in the description, it explains the `mutation` parameter's structure (optional fields, counts, provenance) and `write_to` defaults/path confinement. `root` is not explained but is a common path parameter. This compensates well for the lack of formal param 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 validates and persists a mutation summary to a specific artifact (`.sumo-qa/mutation.json`). It provides common phrasings that map to the tool, distinguishing it from siblings that perform other QA tasks.

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 this tool is for 'FILE/FORMAT PLUMBING ONLY' and that the host skill runs the mutation tool, providing clear context. It does not, however, explicitly list when not to use it or name alternative 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 indicate readOnlyHint=false and destructiveHint=false, consistent with the mutation described. The description adds that it writes to a specific YAML file and detects duplicates, but does not detail permissions, side effects, or error behavior. This adds moderate context 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?

Description is well-structured with a clear first sentence, details, an example, and common phrasings. It is front-loaded with the purpose. Slightly long but every part adds value; could be trimmed slightly but overall good.

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?

Tool has one complex parameter and no output schema. Description covers the parameter thoroughly and explains behavior (duplicate detection, file path). It does not mention return value or error cases, but the example implies success. Given constraints, it is fairly complete.

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

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

Input schema has only one parameter 'entry' with no property descriptions and 0% schema coverage. The description compensates excellently by providing a full example dict with all common fields (id, environment, domain, etc.) and explicitly instructs to pass as a literal dict, not a YAML string. This adds crucial meaning beyond the schema.

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

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

Description explicitly states 'Add or update a known-good test data entry in the local YAML catalogue', clearly indicating the action and resource. It also explains duplicate detection and file location, distinguishing it from sibling tools like sumo_qa_find_test_data and sumo_qa_validate_test_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?

Description includes common natural language phrasings that map to this tool, helping the agent recognize when to use it. It also describes duplicate detection logic. However, it does not explicitly state when not to use this tool or provide alternatives among siblings, so usage guidance is good but not fully comprehensive.

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

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

With no annotations provided, the description carries full burden. It discloses the multi-step process (reads diff, surfaces risks, runs tests, delivers verdict section by section with confirmation gates) and a key behavioral constraint (refuses to claim safe-to-merge without verification). This gives reasonable insight into 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 a single paragraph of ~4 sentences, front-loading the usage trigger. It is efficient but could be broken into bullet points for readability. 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 no parameters, no output schema, and no annotations, the description covers the essential workflow and constraints. It explains what the tool does, how it delivers results (section by section with gates), and its refusal behavior. While more details on test execution feedback could be added, it is complete enough for an agent to decide.

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 zero parameters, so the description does not need to add parameter meaning. According to scoring guidelines, 0 parameters gives a baseline of 4. The description provides context about what the tool acts on (diff, files) but does not mislead.

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 begins with 'Use when the user asks...' which clearly identifies the trigger and action. It specifies the key steps: reading diff, surfaced findings, running tests, delivering verdict. This distinguishes it from sibling tools like sumo_qa_analyze_diff_impact that may only analyze without the full review cycle.

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 ('review my changes', 'is this safe to merge', 'what could break') and what the tool does (reads diff, tests, delivers verdict). It also notes what it refuses to do (claim safe-to-merge without fresh evidence). However, it does not explicitly contrast with all siblings or provide when-not-to-use scenarios.

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 are all false, so the description carries full burden. It discloses that the tool reads the repository and optionally writes an artifact to disk via `write_to`. It notes that the artifact is deterministic except for a timestamp field. It does not mention permissions or side effects (no destructive hint, so writing is not destructive). Adequate transparency for a non-destructive scan tool.

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

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

The description is concise and front-loaded with the core purpose. The natural-language phrasings are helpful but add length. Each sentence earns its place, though the description could be slightly tighter. Still efficient overall.

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 there is no output schema, the description explains what the tool returns (compact summary with various counts) and what the optional artifact contains. It covers the key aspects. For a scan tool with 3 parameters, the description is sufficiently complete.

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

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

Schema coverage is 0%, so description fully explains parameters. It describes `root` as the repository to scan, `generator_version` defaults to installed version, and `write_to` as optional path for writing the artifact. It adds determinism context for the output. This fully compensates for the lack of schema 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 walks a repository and returns a compact QA-relevant summary, listing specific outputs (per-type node counts, edge counts, command counts, warning counts). It distinguishes from siblings like sumo_qa_query_repo_map by noting it generates the artifact, while query_repo_map likely queries it. The purpose is specific and actionable.

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 common natural-language phrasings that trigger this tool, such as 'map this repo' or 'scan the repo'. This helps agents select it. However, it does not explicitly state when not to use it or contrast with siblings beyond implicit behavior. Clear context for use is given, but exclusions are missing.

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?

Description explains return format (raw CLI output with hint) and rationale for raw output to avoid breaking on format drift. No contradiction with annotations (readOnlyHint: true, etc.).

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: first clearly states purpose, second adds critical behavioral context without unnecessary detail.

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?

Covers return format and rationale well, but missing edge cases like empty results or error handling. Given simplicity, nearly complete.

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

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

Only parameter 'query' has no description in schema or tool description. No format, example, or constraints provided, leaving the agent to infer.

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

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

Specific verb 'search' and resource 'Skills CLI registry for external agent skills' clearly state the tool's function, distinguishing it from siblings like check, install, execute, and suggest.

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?

Implied usage for searching skills but no explicit guidance on when to use vs alternatives or any 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?

No annotations are provided, so description must disclose behavioral traits. It mentions 'deeper evidence selection' but does not explain what the tool does concretely (e.g., returns evidence? selects from a pool?), nor does it address side effects, authorization, or state changes.

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?

Single sentence front-loaded with the usage cue 'Use when.' Every word serves a purpose, no fluff. Appropriate length for a zero-parameter tool.

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

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

Given no output schema and no annotations, the description provides essential purpose and usage context but lacks details on return value or procedural behavior. 'Deeper evidence selection' remains ambiguous, leaving gaps for an agent deciding invocation.

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

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

No parameters exist, so baseline is 4. Description adds no parameter info, but that is acceptable since schema coverage is 100% and there are no parameters to explain.

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 this tool is for explicit security testing or grounded security gaps requiring deeper evidence selection. It distinguishes from sibling tools that focus on general QA processes like plan creation, gap analysis, or test execution.

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

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

Provides explicit condition: 'Use when explicit security testing or a grounded security gap needs deeper evidence selection.' Does not list when to avoid or alternatives, but the condition is specific enough to guide selection among 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?

The description outlines the step-by-step process (from repo inventory to residual risks) and mentions the use of 'host's file tools', providing full transparency about the tool's behavior without any annotations needing disclosure.

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

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

The description is two sentences: the first clearly states purpose with examples, the second details the process. It is concise, front-loaded, and 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 no parameters, no output schema, and no annotations, the description provides a thorough explanation of the tool's purpose, usage, and behavior, making it fully complete for an agent to decide when to invoke 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?

The tool has zero parameters, so the description need not explain them. The 100% schema coverage is trivial, and the description adds value by explaining the tool's operation, consistent with the baseline score of 4 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 explicitly states the tool is for 'repo-wide / policy-shaped asks' and gives concrete examples like 'audit our test coverage', which clearly defines its purpose and distinguishes it from siblings focused on specific tasks like diff impact analysis or test plan creation.

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 the tool (for strategic, repo-wide questions) and includes example queries, but does not explicitly state when not to use it or compare with alternatives like sumo_qa_creating_test_plan or sumo_qa_deciding_approach.

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

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

With no annotations, description carries full burden. It discloses that production code stays unchanged and outlines the step-by-step process with confirmation gates. However, it does not detail whether tests are automatically modified or what specifically changes in test files (e.g., assertions).

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

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

Three sentences with zero waste. Front-loaded with usage context, followed by workflow steps, and ends with a key behavioral constraint. 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 no parameters, no output schema, and no annotations, description adequately covers purpose, usage, and workflow. It mentions what stays unchanged (production code) but could elaborate on effects on test files. Overall, it is sufficiently complete for a zero-parameter tool.

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

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

Tool has zero parameters, so baseline is 4. Description correctly omits any parameter details as none exist. No information is needed beyond what is already provided by schema (100% coverage of empty params).

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 clearly states the tool's purpose: strengthening tests after sumo-qa-deciding-approach picks strengthen-test-coverage. It specifies a workflow (survivor → tautology check → technique → strengthening test) and explicitly distinguishes itself from siblings by referencing a specific decision outcome.

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 states when to use: 'Use after sumo-qa-deciding-approach picks strengthen-test-coverage.' Provides context (mutation-testing follow-up, raise-coverage tasks) but does not list explicit exclusions or alternatives. Still, it offers clear guidance for the intended use case.

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

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

With no annotations, the description reveals key behaviors: confirmation before install, fallback on failure, and invocation constraints. However, it omits details about output, persistence of installation, authentication needs, or other side effects, leaving gaps in transparency.

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 concise single paragraph that front-loads usage scenarios. Minor redundancy ('through sumo-qa MCP tools') exists, but overall it is 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 no output schema, the description fails to explain what the tool returns (e.g., success, result, or error). It also assumes domain knowledge and does not reference sibling tools within the suite, leaving the agent with incomplete context for a complex 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?

The input schema has no parameters, so schema description coverage is 100%. The description does not add parameter semantics because none exist, meeting the baseline of 3.

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 role: it finds, installs, and executes external skills when no native sumo-qa sub-skill fits or for ingestion conversion. It distinguishes itself from siblings by specifying the exact entry points (deciding-approach fallback or ingestion conversion) and the actions performed.

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 when to use this tool (as a fallback or for ingestion conversion) and notes it is never invoked cold. However, it does not explicitly exclude other scenarios or directly compare to sibling tools like sumo_qa_install_external_skill, though the dual install/execute behavior is implied.

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

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

No annotations provided, but description fully discloses behavior: reads failure output, classifies cause, names next isolation step, and explicitly states it does not patch. Provides complete behavioral context.

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

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

Description is concise, front-loaded with usage condition, and every sentence adds value. No redundant or vague language.

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 no parameters, no output schema, and no annotations, the description is complete: it explains input (user query), process, output (next step), and boundaries (no patching).

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?

Input schema has 0 parameters with 100% coverage, so baseline is 4. Description adds no parameter info since none exist, but it explains the process sufficiently.

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 clearly states the tool is for diagnosing test failures or flakiness when cause is unknown. It uses specific verb 'triages' and resource 'test failures', and distinguishes from siblings by focusing on the triage phase.

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

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

Explicitly says 'Use when a test is failing or flaky and the cause is not yet known', gives example user queries, and clarifies it does not patch but only diagnoses and routes to fixing skill when appropriate.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds that no downstream mutation occurs and describes the return payload (confidence, freshness, reason), enhancing behavioral 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 extremely concise—two sentences plus a bulleted list of example phrasings. Every sentence adds value, with the main verb and scope stated first. No redundant details.

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 validation tool with no output schema, the description covers purpose, parameter options, return contents, and usage context. It is fully sufficient for an agent to select and invoke 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 0%, but the description explains the two parameters: entry_id (looked up in catalogue) and entry (full record dict). This adds critical meaning that the schema alone lacks, effectively compensating for missing schema 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 validates test data entries without side effects, distinguishing it from mutation tools. It provides specific verb+resource ('Validate a test data entry') and includes common natural-language queries, making the purpose unmistakable.

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 notes the tool does not provision or mutate, indicating appropriate use for read-only validation. While it lacks explicit comparison to sibling tools, the natural-language phrasings guide usage context. No false exclusions present.

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

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

No annotations provided, but the description explains that it triggers sub-skills and establishes global discipline, indicating its role as a router without side effects. Could mention if any state is modified, but likely none.

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 somewhat verbose with many examples, but it front-loads the critical instruction. Could be more succinct by grouping examples.

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 no output schema and no annotations, the description adequately explains the tool's role as a router and lists many sub-tasks, making it complete enough for an agent to understand its function.

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?

Input schema has 0 parameters and schema description coverage is 100%, so description does not need to add parameter meaning. Adding parameter info would be redundant.

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: it is the mandatory entry router for all sumo-qa work, listing many example QA requests. It distinguishes itself from siblings by being the first tool to call.

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

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

Explicitly says 'MUST be called first for any QA-shaped request' and instructs not to answer QA questions from training-data knowledge, directing to route through this tool, providing clear when and when-not to use.

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