rush

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

With no annotations provided, the description carries the burden of behavioral disclosure. It clearly discloses a non-mutating behavior ('without rewriting') and specifies an edge-case behavior: 'missing actionlint returns status=\'skipped\''. This gives the agent useful expectations beyond the schema.

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 sentence with two tightly packed clauses. The primary action is front-loaded, and the behavioral caveat about missing actionlint is placed second. No filler words or redundant schema 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?

An output schema exists, so return value documentation is not the description's responsibility. The description covers tool behavior and a key edge case, but it leaves the 'path' parameter ambiguous and does not explain what 'without rewriting' means operationally. Given the one-parameter complexity and existing output schema, the description is adequate but has clear 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?

Schema description coverage is 0%, so the description must compensate for the single required 'path' parameter. The description does not explain what 'path' should point to — a workflow file, a directory, or a repository root — leaving the agent to guess. The parameter name and format offer limited guidance, but the description adds no semantic value for it.

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

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

The description states a specific verb and resource: 'Check GitHub Actions workflows'. It also adds a distinguishing behavior, 'without rewriting', which helps separate it from tools that might modify or format workflows. It does not explicitly name a sibling, but the purpose is immediately understandable.

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 phrase 'without rewriting' implies a usage condition, suggesting this tool is for checking workflows without making changes. However, it does not explicitly state when to prefer this tool over alternatives like rush_ci or rush_yaml, nor does it provide exclusions or alternative routing.

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 for behavioral disclosure. It does reveal a permission requirement for live inference, but it does not describe side effects, what path refers to, or what happens when permissions are missing.

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 with no filler: the purpose is front-loaded, and the permission caveat is placed immediately after. 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 8 parameters, no annotations, and no parameter descriptions, an agent cannot confidently determine what path should contain or which allow flags are required for a given run. The output schema helps with return values but does not compensate for the missing operational 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It vaguely relates to the allow_* flags by mentioning explicit permissions, but it never explains path, allow_slow, allow_browser, or any other parameter's role.

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

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

The description states a specific action ('Evaluate') with concrete objects ('LLM prompts, agent workflows, and safety guardrails'), which clearly communicates what the tool does. It distinguishes itself from the general lint/test/review siblings, though it does not explicitly contrast with related AI-focused siblings.

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

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

The only guidance is 'Requires explicit permissions for live inference runs,' which is a prerequisite rather than a usage guideline. There is no indication of when to prefer this tool over alternatives like rush_review or rush_hallu_guard, and no exclusion criteria.

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 fll burden. The verb 'detect' implies a non-mutating comparison, and 'against base Git ref' adds behavioral scope, but side effects, read-only guarantees, and any required repository state are not disclosed. It is adequate but minimal.

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

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

A single sentence, front-loaded with the core action and scope, with no filler or redundancy. It is concise while carrying the essential 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 tool with one optional parameter and an existing output schema, the description covers the core behavior and the key input. It lacks explicit usage guidance and behavioral safety disclosure, but the simplicity of the tool means the description is otherwise complete enough for correct selection.

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

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

The schema only provides a 'base' parameter with a default of 'main' and no per-parameter description. The description clarifies that this parameter is a Git ref to compare against, adding meaning beyond the bare schema field. It does not specify accepted ref formats, but 'Git ref' is reasonably informative.

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

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

The description states a specific verb ('Detect') and resource ('breaking public API changes') and clarifies the comparison scope ('against base Git ref'). This clearly distinguishes the tool from the broad sibling list, which are mostly format/lint/test/release utilities.

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 use case is implied by the description: run it when you need to detect breaking public API changes relative to a base git ref. However, there is no explicit 'when not to use' or alternative tooling, despite siblings like rush_semantic-drift and rush_contract that could plausibly overlap.

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 verb 'validate' implies a non-mutating analysis of architecture boundaries, which is a meaningful behavioral signal. However, with no annotations and no explicit statement about read-only guarantees or failure behavior, the description leaves some behavioral traits implicit.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It states the exact validation target in minimal words, which is well-suited to a zero-argument 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?

For a zero-parameter tool with an output schema, the mechanical invocation is fully covered. The main gap is the lack of selection context among the many sibling quality/architecture tools, leaving the agent to infer when this guard is the right choice.

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 there is no parameter ambiguity or invocation risk. The baseline for a 0-parameter tool is 4, and the description does not need to compensate for missing parameter documentation.

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

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

The description uses a specific verb ('validate') and a unique focus ('clean architecture layer boundaries'), which clearly distinguishes it from generic lint/test/review tools. It does not explicitly name sibling tools or say what it is not, so it misses the full 5-level differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like rush_lint, rush_review, or rush_semantic-drift. The purpose phrase implies the domain, but no preconditions, exclusions, or alternative routing 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 the full burden of behavioral disclosure, but it only states that a statement is generated. It does not reveal whether this modifies the artifact, writes a file, requires signing/key material, or returns provenance to stdout.

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 informative sentence with no filler, and the key term 'SLSA Level 3' is front-loaded. It is concise, though it sacrifices contextual 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?

For a tool with no annotations, zero parameter documentation, and a broad sibling list, the description omits enough guidance to be reliably used. The presence of an output schema helps the return-value side, but artifact path semantics and invocation prerequisites are still unexplained.

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

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

Schema description coverage is 0% and the description never mentions artifact_path or explains what path should be supplied. The schema only provides a title and default, so the description adds no meaning beyond structured fields.

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

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

The description names a specific action ('Generate') and a precise resource ('in-toto SLSA Level 3 provenance statement'), which is distinct from every sibling tool name in the list. An agent can immediately identify what this tool produces without needing to open the schema.

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

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

No guidance is provided about when to choose this tool, what artifact it should be run on, or how it relates to alternatives such as rush_sbom or rush_license_matrix. The agent is left to infer usage entirely from the tool name and parameter name.

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

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

With no annotations, the description carries the full burden. It does disclose the core behavioral trait: the analysis is non-destructive ('Calculate'), transitive, and downstream-only, which is genuinely informative. However, it omits operational details an agent would want, such as whether a built dependency graph or git state is required and how expensive a deep transitive traversal can be.

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

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

A single 11-word sentence, front-loaded with the verb and densely packed with distinguishing qualifiers ('downstream', 'transitive', 'changed file'). Every word earns its place; there is no filler, redundancy, or buried 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 two-parameter analysis tool with an output schema, the description covers the essential purpose and the required input's meaning. But the 'blast radius' domain jargon is left undefined (only partially glossed by 'downstream transitive'), depth semantics are absent, and environmental prerequisites are unmentioned, leaving the agent to proceed on inference.

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 is the only semantic source for parameters. It usefully clarifies that 'path' refers to a changed file, sharpening the bare string schema. 'depth' (default 5) receives no explanation — the agent must infer it caps traversal depth from the word 'transitive', with no confirmation.

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

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

The description states a specific verb ('Calculate') and a well-scoped resource ('downstream transitive blast radius for a changed file'), conveying both the operation and its granularity in one sentence. It clearly differentiates from the 60+ sibling tools, none of which address impact or blast-radius analysis.

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 phrase 'for a changed file' implies the triggering scenario — run this after modifying a file to assess downstream impact — but the description never states when to prefer this tool over alternatives or when not to use it. No sibling is contrasted or named, so usage context is implied rather than articulated.

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 supplied, the description carries the behavioral disclosure burden. It does so well by stating the operation is inspection-only and explicitly ruling out credential and remote-status access. It doesn't enumerate failure modes or whether the config is merely read, but 'inspect' plus the exclusions provide a clear non-mutating profile.

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

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

A single tightly packed sentence that front-loads the purpose and then adds the key constraints. There is no filler 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?

This is a simple one-parameter read-oriented tool and an output schema is present, so the description doesn't need to explain return values. It covers the main safety-relevant behavior (no credentials/remote status). The only slight gap is not clarifying path semantics, but the overall context is strong.

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 only parameter, 'path', has no schema description (0% coverage), so the prose must compensate for parameter meaning. The description's 'local CI workflow configuration' makes it inferable that the path points to a CI workflow configuration, but it never explicitly states whether the path should be a file or directory, or how it relates to the CI config. This is adequate but not fully explicit.

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

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

The description uses a specific verb ('Inspect'), names the resource ('local CI workflow configuration'), and adds two explicit exclusions ('without accessing credentials or remote status'). This clearly differentiates it from remote/credential-related siblings and is far beyond a restatement of the name.

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

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

It clearly implies when to use: when you need to inspect local CI workflow configuration and do not need remote status or credentials. However, it does not name any alternative tools or state explicit when-not conditions in relation to siblings, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses that it can run under --allow-build, but it does not explain side effects such as slow execution, build invocation, network usage, or artifact/cache writes. The many allow_* parameters hint at behavior, but the description itself adds almost no transparency beyond the mode names.

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 compact sentence with no filler, which is structurally clean. However, it is terse to the point of under-specification, merging two distinct modes into one clause without any separation or elaboration.

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

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

Despite an output schema being present, a CodeQL tool with two modes, nine parameters, and no annotations needs more context to be callable correctly. The description omits how to choose modes, what the allow flags enable, expected behavior, and potential side effects. It is not complete enough for safe autonomous 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?

Schema description coverage is 0%, and the description only indirectly references report_path and allow_build via 'SARIF report' and '--allow-build'. Required path and the other seven flags, including allow_slow, allow_network, and allow_artifact_write, receive no semantic explanation. This is minimal added value for a nine-parameter tool.

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

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

The description names two concrete operations: importing a local CodeQL SARIF report and running CodeQL analysis with --allow-build. This clearly identifies the tool's resource and action, and CodeQL is specific enough to distinguish it from most siblings. It does not explicitly contrast with rush_security, but the purpose is not vague.

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

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

The description gives no guidance on when to use this tool versus alternatives like rush_security, nor does it explain when to import a SARIF report versus run an analysis. The two modes are implied, but the conditions for choosing one are left entirely to the reader.

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 of behavioral disclosure. It does disclose the key non-mutating trait ('without modifying Git history'), but it omits other important behaviors such as how invalid messages are reported, exit codes, or whether validation is purely local. This is a partial disclosure at best.

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 compact sentence with the action front-loaded and no filler words. It is appropriately concise, though its brevity comes at the cost of omitting parameter and usage 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 tool with 9 parameters, no schema descriptions, and no annotations, this one-liner is incomplete. The output schema may cover return values, but the agent still lacks critical context about what 'path' refers to, how the commit message is supplied, and what the allow_* toggles control. The large undifferentiated sibling list increases the need for 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?

Schema description coverage is 0% and the description mentions none of the 9 parameters. The required 'path' is unexplained, 'message' is not clearly tied to the supplied commit message, and the seven allow_* boolean flags have no described meaning, so an agent cannot infer correct usage from the description.

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

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

The description states a specific action ('Validate') and a specific resource ('Conventional Commit messages'), and adds a useful boundary by noting it does so without modifying Git history. This distinguishes it from mutating Git operations, though it does not explicitly name a sibling alternative.

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

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

There is no guidance on when to use this tool versus the many sibling rush_* tools, nor any workflow context such as pre-commit usage or CI integration. The single sentence implies purpose but gives no conditions, exclusions, or 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 are provided, so the description bears the full burden of behavioral disclosure. It usefully reveals reliance on external engines (radon/jscpd) and the 'skipped' status when they're missing. It does not state whether the operation is read-only or mention other side effects, but the mention of engine availability is meaningful.

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

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

Two short sentences deliver the core action, the target languages, the location, and an important edge case. The main purpose is front-loaded and every word contributes, with no redundancy or filler.

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

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

An output schema exists, so return values need not be described. The description covers the operation, languages, path, and missing-engine behavior. The only notable omissions are a precise definition of what metrics constitute 'complexity' and how engine selection works, but these are not required to invoke 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?

The schema provides only a 'path' parameter with no description (0% coverage). The description adds that <path> is the location where complexity is measured, which provides basic semantic grounding. It does not specify whether the path should be a file or directory, leaving some ambiguity.

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

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

The description states a specific verb (Measure), a specific resource (Python and JS/TS complexity), and a location parameter (<path>). This clearly differentiates it from sibling tools like rush_lint, rush_test, or rush_format by focusing on complexity analysis.

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 intended use is implied clearly: call this tool when you need complexity metrics for Python or JS/TS at a given path. It does not explicitly name alternative tools or when-not-to-use conditions, but the context is unambiguous enough for an agent to select it appropriately.

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 behavioral disclosure burden. It clearly states the tool is non-rewriting and mentions a specific edge-case behavior: missing hadolint results in status='skipped'. This gives the agent useful behavioral expectations beyond the schema.

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, dense sentence that front-loads the core action and then adds the most important behavioral detail. There is no filler or repetition of schema information.

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

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

For a one-parameter, read-only checking tool with an output schema, this description covers the key selection and behavior information: what it checks, that it doesn't rewrite, and a special status outcome. It is slightly thin on what exactly 'check' entails, but the output schema likely fills that gap.

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

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

Schema coverage is 0%, so the description must compensate for the undocumented path parameter. It indirectly implies that 'path' points to container files, but it never explicitly states whether the path should be a file or directory, or what formats are accepted. The semantic contribution is present but minimal.

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

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

The description states a clear verb and resource: checking container files without rewriting. It is specific enough to distinguish this from siblings like rush_markdown or rush_yaml, though it doesn't name an alternative or use a more precise verb like 'lint'.

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 phrase 'check container files without rewriting' implies the intended use case: read-only validation of container files. However, there is no explicit guidance about when to choose this over sibling tools like rush_lint, nor any exclusion criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Get' implies a read operation and 'real-time' indicates data freshness, but there is no mention of side effects, access requirements, rate limits, or what scope of data is covered, so behavioral transparency is minimal.

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

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

A single sentence with no filler; the key qualifier 'real-time' is front-loaded and every word contributes to identifying the metric. It is concise without being under-specified to the point of uselessness.

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 tool is simple with no parameters and an output schema exists, so invocation requirements are minimal. However, the description gives no sense of when this metric is relevant versus siblings like rush_token_outline, and the meaning of 'token economy savings' is left largely to inference.

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

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

The tool has zero parameters and an empty input schema, so schema coverage is trivially complete. The description does not need to explain parameter behavior; for a no-parameter tool the baseline of 4 applies.

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

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

The description uses a specific verb ('Get') and names a concrete resource ('real-time token economy savings and cost metrics'), making the basic function clear. It does not explicitly distinguish itself from siblings like rush_token_outline or rush_context_retrieve, but the resource name is specific enough to identify the 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?

There is no guidance about when to use this tool instead of a sibling such as rush_token_outline or rush_context_pack, nor any mention of context or conditions. The description provides no exclusionary information, so an agent receives no help with selection among the large family of rush_* 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Check', which implies a read operation but does not state side effects, whether it requires a particular repository state, how it defines a mistake, or what it does with the reverts found.

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 one short sentence with no filler, wasted words, or irrelevant details. It is front-loaded with the action and resource, making it easy to parse quickly.

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

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

With zero parameters and an output schema present, invocation requirements are minimal. However, the description is thin on behavioral context: it does not clarify what qualifies as a mistake or anti-pattern, nor whether the check is purely read-only. It is minimally adequate but leaves meaningful ambiguity.

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

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

The tool has zero parameters and full schema coverage, so there is no parameter documentation burden on the description. The baseline for a 0-parameter tool is 4, and the description adds no conflicting or misleading parameter information.

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 has a clear verb ('Check'), a specific resource ('git revert history'), and a target purpose ('past mistakes and anti-patterns'). It is reasonably distinct from the sibling tools, though the exact meaning of 'mistakes' and 'anti-patterns' is left somewhat vague.

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?

No when-to-use guidance, exclusions, or alternative tools are mentioned. The agent must infer that this tool is relevant when reviewing git history for past errors, and it is not told how to choose between this and related review/context 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?

With no annotations provided, the description must carry the full behavioral burden. It states a high-level operation but does not disclose side effects, cache writes, file modifications, return format, or failure behavior. The allow_cache_write parameter hints at a write effect, but the description never mentions it.

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 very compact and readable, putting the core action and constraint upfront. However, it is so terse that it omits essential operational details, making it under-specified rather than efficiently concise.

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

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

Given four parameters, no annotations, and no output schema, the description is not sufficient for an agent to confidently invoke the tool. It leaves usage context, parameter meanings, and behavioral consequences unaddressed.

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 explain the parameters. It only hints at the 'budget' parameter via 'strict token budget,' while 'path', 'symbol', and 'allow_cache_write' remain unexplained.

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

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

The description names a specific action ('Pack') and a distinct resource ('graph-pruned context outline') with a clear constraint ('strict token budget'). It communicates more than the tool name alone, though the term 'graph-pruned' is somewhat jargon-heavy and the exact meaning of 'pack' is left implicit.

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

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

No guidance is given for when to use this tool versus the many context-related siblings such as rush_token_outline or rush_context_retrieve. The intended use is only implied by the verb 'pack' and the token-budget phrase.

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 at all, the description carries the full burden of behavioral disclosure. 'Retrieve' implies a read operation, and 'uncompressed content' hints at the expected result, but there is no mention of failure behavior, response format, size limits, or effects beyond retrieval, which is minimal for an unannotated tool.

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

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

The description is a single, direct sentence with no redundant wording. Key information—action, target, and selection mechanism—is efficiently packed and 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?

Without an output schema or annotations, the description leaves notable gaps: the return format is unspecified, error/not-found behavior is absent, and the meaning of 'path' in the input schema is unexplained. It is adequate for a very simple lookup but incomplete for safe autonomous use.

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 explain the parameters itself. It partially clarifies chunk_hash via 'by hash', but the optional 'path' parameter is not mentioned at all, leaving its purpose and relationship to the chunk store unexplained.

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

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

The description states a clear action ('Retrieve'), a specific resource ('CCR chunk store'), and the lookup key ('by hash'). This distinguishes it from related context sibling tools like rush_context_pack and rush_context_mistakes_check, which clearly do different things.

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 phrase 'by hash' implies this tool should be used when the caller already has a chunk_hash and wants uncompressed content. However, it does not explicitly contrast with alternative tools or state when not to use it, leaving usage guidance mostly implicit.

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

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

With no annotations, the description must carry behavioral disclosure itself. It communicates one critical side-effect (saving writes to cache only with explicit permission) and clarifies the local scope. It does not explain what restore overwrites or how the coordination/provider_resume modes behave, leaving significant behavioral opacity.

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, front-loaded with the core action and no filler. The return-shape note and permission caveat each add something an agent needs to know. It loses no points on conciseness, though the first sentence is incomplete about the full operation set.

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 23 parameters, a 9-value operation enum, no annotations, and roughly 60 sibling tools, this two-sentence description cannot be contextually complete. It omits six operation modes, does not specify which parameters apply to which operation, and does not address coordination or provider-resume behavior. The output schema covers return shape, but not the 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?

Schema description coverage is 0%, so the description needed to compensate for 23 undocumented parameters. It only suggests that saving requires cache-write permission and that the checkpoint is local; most parameters—path, name, files, token_budget, and operation-specific fields—are left unexplained. This is minimal compensation for a very large 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 verbs save/list/restore and the resource 'local Rush session checkpoint' name a concrete core action, so it is not a tautology. However, the operation enum exposes six additional modes (context_pack, context_retrieve, coordination_*, provider_resume) that the description never mentions, making the stated purpose partial and potentially misleading. It also does not differentiate this tool from the many sibling rush_context and rush_mesh tools.

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

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

No sentence tells an agent when to prefer rush_continuity over a sibling or which operation mode fits which scenario. The 'local' qualifier and cache-write permission note hint at some conditions, but there are no explicit alternatives, exclusions, or workflow guidance for a tool with nine operational modes.

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 of behavioral disclosure. It does not explain side effects, network/build/browser allowances, whether imports mutate state, or what the output schema represents beyond a vague hint about --allow-slow.

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 concise sentence with no filler. It front-loads the core action, though the ambiguity between 'import' and 'run' slightly reduces structural clarity.

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

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

For a tool with nine parameters, no annotations, and a non-obvious dual operation, the description is far too thin. It does not explain which input triggers import versus verification, what the allow_* flags control, or how the output schema relates to the operation.

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%, yet the description only adds meaning to 'allow_slow' and loosely touches on a local Pact report ('path'). The other seven parameters, including report_path and all allow_* flags, remain unexplained, so the description does not compensate for the missing schema documentation.

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

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

The description names a concrete resource ('local Pact report') and actions ('import' or 'run local contract verifications'), so it is more than a tautology. However, it presents two loosely joined operations and does not clearly explain which one happens under which conditions, making the tool's primary function ambiguous.

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

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

There is no explicit guidance on when to use rush_contract versus siblings like rush_test, rush_review, or rush_snapshot. The intended use is only implied by the name and the vague mention of contract verifications, leaving an agent to infer the appropriate 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?

No annotations are provided, so the description carries the full burden of disclosing behavior. It mentions two high-level operations but does not explain side effects, whether importing writes files, what the allow_* flags actually permit, or what happens during a slow analysis. '--allow-slow' hints at a performance trade-off but remains unexplained.

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 sentence with no filler and front-loads the core purpose. The phrase 'under --allow-slow' is slightly cryptic, but overall the description is efficient and readable.

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

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

With nine parameters, no annotations, and no parameter descriptions in the schema, one sentence is insufficient for an agent to confidently invoke this tool. Important details about mode selection, the role of report_path, and what the allow_* flags control are missing.

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

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

Schema description coverage is 0%, so the description must compensate. It adds minimal meaning for 'path' (local coverage report) and 'allow_slow' (--allow-slow), but the remaining seven parameters—including report_path, allow_build, allow_browser, allow_network, and allow_artifact_write—are not described beyond their self-explanatory names.

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 identifies a specific coverage-related resource and names two concrete operations: importing a local report or running coverage analysis. 'Under --allow-slow' is somewhat ambiguous, but the overall purpose is clear and distinguishable from sibling tools like rush_lint or rush_test.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as rush_test or rush_complexity. The description implies a choice between import and analysis modes, but it does not explain when each mode is appropriate or what prerequisites apply.

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 responsibility for behavioral disclosure. The word 'Audit' and 'detect' imply a read-only inspection that does not modify data, but the description does not explicitly state side effects, permissions, connection requirements, or what happens when drift is found.

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

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

A single, focused sentence conveys the action, inputs, and expected result without redundancy. It is front-loaded and every word adds 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?

With no parameters and an output schema available, the description is sufficient for an agent to understand what the tool does and when it is relevant. No additional return-value details are needed because the output schema exists.

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 baseline is 4. The description correctly focuses on the tool's purpose rather than parameters because there are no parameters to document.

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

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

The description uses a specific verb ('Audit'), identifies the resources being compared (ORM models vs migrations), and names the exact outcome (detect schema drift). This clearly distinguishes it from siblings like rush_semantic-drift, which targets semantic drift rather than database migration schema drift.

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 intended use is implied: run this when you want to find schema drift between ORM models and migrations. However, it does not explicitly state when not to use it, nor does it point to any sibling alternative such as rush_semantic-drift or rush_sql for related but different checks.

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 of behavioral disclosure. It does reveal a useful edge-case behavior: missing engines return status='skipped', and it names the underlying tools. However, it does not mention whether the scan is read-only, whether it requires configuration files, or what other statuses may appear.

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 sentence that front-loads the main purpose and then adds the key engine detail and edge-case behavior. There is no filler, repetition, or unnecessary explanation.

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

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

For a tool with one simple path parameter and an output schema, the description covers purpose, language scope, tooling, and a behavior on missing engines. A minor gap is that it doesn't explicitly map vulture to Python and knip to JS/TS, but this is easily inferred and not critical for 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?

The schema has 0% description coverage, and the description only repeats the path placeholder as '<path>' without adding format, constraints, or examples. The parameter is self-explanatory from its name and format, so the impact is minor, but the description adds no semantic value 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 uses a specific verb ('Find') with a clear resource ('unused Python and JS/TS code') and a path argument. It also names the underlying tools (vulture or knip), which distinguishes it from siblings like rush_dead_asset and other analysis tools.

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

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

The description implies the tool is for dead code detection and notes behavior when engines are missing, but it does not explicitly state when to use this tool over siblings or when not to use it. The context is clear enough for basic selection, but no exclusions or alternatives are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says 'Scan' but does not clarify whether the tool is read-only, what it reports, whether it modifies files, or what constitutes 'dead media'. This is thin coverage for a tool that may perform analysis.

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 one short, front-loaded sentence with no filler or redundant phrasing. It is efficient, though the phrase 'dead media' is somewhat jargon-heavy and could be clearer.

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

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

With zero parameters and an output schema available, the core call shape is reasonably complete. However, the lack of behavioral disclosure and the absence of any guidance distinguishing this tool from rush_dead leave meaningful gaps for an agent trying to select and invoke 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?

The input schema is empty and schema description coverage is 100%, so there are no parameters for the description to document. With zero parameters, the description has no additional burden to explain argument semantics.

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

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

The description names a specific verb ('Scan') and a resource ('unreferenced assets and dead media'), so an agent can understand the basic operation. However, it does not differentiate this tool from the closely named sibling 'rush_dead', leaving some ambiguity about exactly which dead-item analysis this tool performs.

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

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

There is no guidance about when to use this tool versus alternatives like rush_dead or other audit/scan siblings. The description implies a scanning purpose but gives no conditions, exclusions, or suggestions for when another tool would be more 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?

With no annotations, the description carries the full burden, but it only states the diagnostic scope and the returned shape. It does not disclose whether the tool is strictly read-only, whether it runs external commands, or what other side effects or requirements exist. The return structure is already covered by the output schema.

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 no filler: the first front-loads the purpose and scope, the second states the return shape. 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?

For a tool with one optional parameter and an output schema, the description is minimally adequate: an agent can call it with defaults and understand the result. It remains incomplete in usage guidance, path semantics, and behavioral safety, which are significant for a diagnostic tool with no 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?

Schema description coverage is 0% and the description only says 'at <path>', which adds little beyond the schema's field name and format. It does not explain what kind of path is expected—project root, directory, config file, or something else—so an agent lacks semantic guidance for the single parameter.

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

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

The description uses the specific verb 'Diagnose' and names concrete resources: environment health, toolchain integrity, and binary resolution at a path. This is clear and distinct from the general 'rush_*' tool names, though it does not explicitly differentiate from diagnostic siblings like rush_iam_audit or rush_security.

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 intended use is implied by the verb 'Diagnose' and the target categories—an agent can infer it should be used when investigating environment or toolchain problems. However, there is no explicit guidance about when to prefer this tool over 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only mentions the --allow-browser gate. It does not state whether the test run can modify the workspace, write caches/artifacts, or make network calls, nor what happens if the required flag is omitted.

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 single-sentence description is terse and front-loaded with the main purpose, which is good. However, given the nine-parameter input schema, it is under-specified rather than appropriately sized; brevity comes at the cost of necessary semantic 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?

For a tool with nine input parameters, two required, and no annotations, this description is far from complete. It covers one condition and does not explain required inputs, the remaining permission flags, or how the tool relates to sibling test tools; the existence of an output schema only slightly reduces the need for return-value explanation.

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 needed to compensate, but it only explains one parameter (allow_browser via '--allow-browser'). It provides no meaning for the required 'path' and 'options' parameters—'options' has no type in the schema—or the other six allow_* flags.

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

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

The description uses a specific verb ('Run') and a specific resource ('configured E2E tests'), so an agent immediately knows what the tool is for. The qualifier 'only with --allow-browser' also signals this is a browser-gated E2E runner, though it never explicitly names a sibling tool such as rush_test for contrast.

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

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

The description gives an explicit invocation condition: use this tool for configured E2E tests and only when --allow-browser is available/enabled. It does not list exclusions or alternatives like 'for unit tests use rush_test', so it stops short of full routing guidance.

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

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

With no annotations, the description carries the burden of disclosing behavior, and it adds useful context: 'Safely' signals caution, 'Enforces strict path confinement' is a concrete safety guarantee, and the return shape is stated. However, it does not explain what 'safe' entails, whether files are modified in place, or how force/dry_run affect execution.

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

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

The description is compact and informative, using three short clauses that each add value: the action, the return format, and the safety constraint. It is front-loaded with the core purpose and has no filler or redundant wording.

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?

Although an output schema exists and the description includes the return shape, the tool has no annotations and the parameter documentation is incomplete. Missing context around force versus dry_run behavior and the exact side effects of remediation leaves an important gap for an agent deciding whether and how to invoke it safely.

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 needs to compensate, but it only clarifies the path parameter via '<path>'. The meaning and effect of 'force' and 'dry_run' are not explained at all, leaving the agent to guess their roles despite them being important for a remediation tool.

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

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

The description clearly identifies the tool as an auto-remediation action for formatting and linter issues at a specific path, using a strong verb ('auto-remediate') and resource ('formatting and linter issues'). It is distinguishable from siblings like rush_lint, but it does not explicitly contrast with rush_format or other closely related tools, so it stops short of a 5.

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

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

The context of use is implied: use this tool when formatting or linter issues need to be automatically fixed at a path. However, there is no explicit guidance about when to prefer rush_fix over rush_lint, rush_format, or rush_review, nor any stated exclusions or prerequisites.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It reveals two modes and one gating flag, but says nothing about side effects, where the report is imported to, required permissions, transformations applied, or whether the operation is read-only or mutating.

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 single sentence is efficient and front-loaded, with no filler words. That conciseness comes at the cost of missing essential detail for a nine-parameter tool, making it under-specified rather than appropriately concise.

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

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

Given nine parameters, no annotations, and only a one-line description, the agent lacks enough context to invoke this tool correctly with confidence. The output schema may describe return values, but invocation semantics, mode selection, and the meaning of most flags are missing.

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

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

Schema description coverage is 0%, so the description must compensate for all nine parameters, but it only lightly touches allow_slow and the JUnit report path. The remaining parameters such as allow_build, report_path, allow_network, and allow_artifact_write receive no semantic explanation at all.

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

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

The description names two actions — importing a local JUnit report and running duplicate test analysis — so it is not a tautology and is somewhat concrete. However, 'duplicate test analysis' is unexplained, and the tool name 'rush_flaky' suggests flaky-test detection but the description never mentions flakiness, forcing the agent to infer intent.

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 conditional 'under --allow-slow' provides a meaningful usage hint, and 'import a local JUnit report' implies a common invocation scenario. There is no explicit guidance about when to prefer this over sibling tools, when not to use it, or what prerequisites apply.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explicitly states the tool is 'Always check-only in v0.1', which is a critical safety trait, and discloses the return shape and per-language engines. It could clarify how the 'check' parameter interacts with the always-check-only behavior, but overall it is transparent.

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

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

The description is compact and front-loaded: the core action comes first, followed by return shape, engines, and the safety caveat. Every sentence adds useful information without repeating schema fields.

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

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

For a simple two-parameter tool with an output schema, the description provides the essential action, language scope, engine mapping, and safety posture. The main remaining gap is the exact meaning of the 'check' parameter and whether 'path' may be a directory or only a file, but these do not prevent 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?

Schema description coverage is 0%, so the description must compensate. It clarifies that 'path' refers to files to format and names the supported languages, and the 'check-only' line hints at the boolean's behavior. However, it never explicitly explains the 'check' parameter's true/false semantics, leaving the default false somewhat confusing given the always-check-only claim.

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

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

The description names a specific action ('Format'), a resource ('Python/JS/TS files at <path>'), and the exact engines used. This clearly distinguishes it from siblings like rush_lint or rush_fix even without an explicit comparison.

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: use it to format Python/JS/TS files, and it is always check-only in v0.1. It does not explicitly name alternative tools or state when not to use it, but the language scope and check-only caveat give a clear operational frame.

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 and low description coverage, the description carries the full burden of disclosing side effects. It mentions --allow-slow as a guard but says nothing about the significant behaviors signaled by parameters such as allow_build, allow_browser, allow_network, allow_download, or artifact writes. It does not state whether it mutates, requires permissions, or runs untrusted code.

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 one compact sentence with no filler, front-loading the two primary use cases and the key guard flag. It is concise and easy to scan, though the dual-mode phrasing creates some ambiguity.

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

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

For a 10-parameter tool with no annotations, the description is far from complete. It omits prerequisites, side-effect profile, semantics of most parameters, and the relationship between the two modes. An agent could not confidently invoke it correctly based solely on this description.

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

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

Schema description coverage is 0%, so the description should compensate. It helps with allow_slow ('under --allow-slow') and weakly implies report_path via 'fuzz report', but it leaves path, options, allow_build, allow_browser, allow_network, allow_download, allow_cache_write, and allow_artifact_write unexplained.

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

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

The description names two concrete operations: importing a local fuzz report and executing local fuzz tests under --allow-slow. It adds a usable verb+resource beyond the tool name and gives a sense of scope, though it does not clearly separate the two modes or distinguish itself from siblings such as rush_pbt.

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

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

The description gives no guidance on when to choose import mode versus execute mode, nor any alternative tool or exclusion condition. A user must infer from parameter names; the description does not say when to prefer rush_fuzz over related 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?

No annotations are provided, so the description carries the full disclosure burden. It only states that the tool 'audits' imports; it doesn't say whether the audit is read-only, how 'installed packages' is determined (current environment, requirements file, or lockfile), or what happens when problematic imports are found (report, exit code, or autofix).

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 9-word single sentence is front-loaded with the verb and contains zero filler; every word earns its place. The brevity that hurts other dimensions is an underspecification problem, not a structure problem.

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

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

An output schema exists, so return values need no explanation, but invocation context is thin: path semantics, read-only vs. modifying behavior, and how 'installed packages' is resolved are all implicit. For a guard-style tool, an agent needs to know whether invoking it can modify the repo or fail the build before committing to it.

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

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

Schema description coverage is 0% - the 'path' property has no description - and the tool description never mentions the parameter. An agent must guess whether path points to a file, directory, or project root, and what the default '' resolves to; the description adds nothing beyond what the param name already implies.

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

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

The description names a specific verb ('audit'), resource ('code imports'), and comparison baseline ('installed packages and stdlib'), so the core function is immediately clear. It also distinguishes itself from likely-overlapping siblings like rush_dead, rush_typecheck, and rush_arch_guard by narrowing to import resolution, though it stops short of explicitly naming an alternative.

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?

No guidance is given on when to use this tool vs. rush_dead, rush_arch_guard, or rush_typecheck. There are no exclusion conditions, no mentioned alternatives, and no context signals such as 'run after dependency changes' - selection is left entirely to the agent's inference from the tool name.

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 of behavioral disclosure. It explicitly states that the tool does not rewrite files and that missing local engines result in a 'skipped' status, which is valuable safety and degradation behavior. It could still elaborate on side effects or prerequisites, but for a simple check tool this is strong 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 a single concise sentence that front-loads the core action ('Check Terraform') and then provides the two most important qualifiers: no rewriting and skip behavior on missing engines. Every word earns its place with no redundancy.

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

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

The tool is simple: one required path parameter, no nested objects, and an output schema exists, so return values do not need to be described. The description covers the main behavior and the skipped-status edge case, but it leaves ambiguity around what 'Terraform' refers to and what exactly happens when local engines are present. It is adequate but has clear 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?

The input schema has only one parameter, 'path', but schema description coverage is 0% and the description never mentions the parameter. The agent is left to infer that 'path' points to a Terraform directory or file. The description does not add meaning about expected format, what the path should contain, or how it is resolved.

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

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

The description states a specific verb and resource: 'Check Terraform'. The phrase 'without rewriting' adds an important scoping detail that distinguishes it from mutation-style tools like rush_fix or rush_simplify. However, it does not name any sibling tool or elaborate on what kind of check is performed, so it is clear but not fully differentiated.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as rush_review, rush_lint, or rush_security. The 'without rewriting' phrase implies a conservative read-only intent, but it does not state exclusions or direct the agent to a different tool under specific conditions.

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

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

No annotations are provided, so the escription carries the full behavioral disclosure burden. It states 'ynthesize' as the behavior but does not disclose whether this modifies anything, requires cloud access, reads existing policies, or purely produces a policy document.

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 phrase is tight and front-loads the core action and object, containing no filler. It is terse, but this dimension rewards brevity and clear structure.

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

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

With no annotations and no parameter context, the escription leaves open whether the tool mutates the cloud environment, what it reads as input, and which cloud provider or scope it targets. The presence of an output schema helps return-value understanding, but operation inputs and side effects are unexplained.

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

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

The tool has zero parameters and the schema is vacuously 100% covered, so there are no parameter formats or semantics for the description to clarify. It does not explain implicit context inputs, but the zero-param baseline applies.

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

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

The description uses a specific verb ('Synthesize') and a concrete resource ('least-privilege cloud IAM policy'), making the core action clear. It does not explicitly contrast with sibling tools, so it stops short of full differentiation.

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

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

There is no guidance about when to use this tool versus alternatives such as rush_iac, rush_security, or rush_review. The one-line description only implies the obvious scenario and gives no prerequisites, exclusions, or 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. 'Audit' hints at read-only analysis, but the description does not explain what the matrix contains, whether it fails on violations, whether it performs network access, or any side effects. This is a notable gap for a tool with no annotation safety signals.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes to the tool's purpose, making it highly scannable for an agent.

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 no-parameter tool with an output schema present, the description provides the essential purpose and scope. It lacks explicit relationship guidance to siblings like rush_sbom or rush_security, but the invocation surface is simple enough that the description is 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?

The tool has zero parameters and the schema coverage is 100% trivially, so the description does not need to explain parameters. The baseline of 4 for no-parameter tools applies; nothing is missing here.

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

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

The description names a specific action ('Audit'), a clear resource ('open-source dependencies'), and the focus ('license risks'). This distinguishes it from sibling tools like rush_security or rush_sbom without needing to open their schemas.

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

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

The purpose implies when it should be used — when license compliance of dependencies needs checking — but it does not explicitly state when to prefer this over alternatives or mention any exclusions. The guidance is reasonable but left implicit.

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

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

With no annotations provided, the description carries the full burden of behavior disclosure. It adds meaningful behavioral details: the return shape {status, findings[], summary}, auto-selection of ruff/eslint, and the meaning of status='skipped'. This is strong, though it could have explained more about side effects or failure modes.

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 short, purposeful sentences. The action is first, return shape second, and engine/status behavior third. Every sentence earns its place with no repetition or filler.

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

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

The tool is simple, an output schema exists, and the description covers the core behavior, return shape, and skip condition. The main gap is the undocumented engine_args parameter, which prevents a 5 but does not undermine basic 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?

Schema description coverage is 0%, so the description must compensate. It explains <path> implicitly and mentions engines, but it never explains the engine_args parameter at all. An agent would not know how to pass additional arguments to the linters from this description.

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

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

The description opens with a specific verb and resource: 'Lint Python/JS/TS files at <path>.' It clearly identifies the tool's scope and distinguishes it from siblings like rush_typecheck or rush_format by naming exact languages and engines.

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

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

The description gives clear context for when to use the tool: linting Python, JavaScript, or TypeScript files, with engine selection based on language. It does not explicitly name alternatives or exclusions, so it stops short of a 5, but the intended use is unambiguous.

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

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

No annotations exist, so the description carries the full burden. It reveals that executing load traffic requires --allow-network, but it doesn't mention side effects, required permissions, or behavior of the allow_* and cache/artifact flags. A mutation-capable tool with this many flags needs significantly more behavioral 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 a single, front-loaded sentence with no filler or repetition. While it is terse, every phrase adds information. It could benefit from structuring the two modes, but it is concise.

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

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

Despite the presence of an output schema, the high parameter complexity and missing annotations require more context. The description fails to explain required arguments, mode selection criteria, or how the permission flags shape behavior. This is not complete enough for reliable tool selection/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?

Schema description coverage is 0%, so the description must explain parameters; it only alludes to allow_network via --allow-network. Required 'path' and 'options' are completely unexplained, as are slow/build/browser/download/cache/artifact options. This is inadequate for 10 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?

Describes a specific capability: importing a local load report or executing load traffic, with the network mode tied to --allow-network. This is clear enough to distinguish it from a generic name, but it doesn't explicitly position it against siblings. The dual 'or' structure introduces some ambiguity about which mode an agent should infer.

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 two use cases (local report import and network-enabled load traffic) and mentions when --allow-network applies. It does not state when to prefer rush_load over related tools or give prerequisites/exclusions. The usage guidance is therefore at the 'implied' level.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that files are not rewritten and that a missing markdownlint-cli dependency yields status='skipped', which is valuable edge-case information beyond the schema.

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

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

A single front-loaded sentence contains the action, the target, the side-effect constraint, and the failure mode. There is no filler or redundancy.

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

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

For a one-parameter tool with an output schema, the description covers purpose, non-destructive behavior, and a key missing-dependency condition. It is brief but not missing critical operational context, though it could name sibling relationships for 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?

The schema provides zero description coverage for the only parameter, and the description adds only 'Markdown at <path>' context. This clarifies that path points to Markdown content but doesn't explain path expectations such as file vs directory, globbing, or requirements.

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

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

The description uses a specific verb ('Check'), a clear resource ('Markdown at <path>'), and an explicit non-rewriting constraint that distinguishes it from formatting-oriented siblings like rush_format. The mention of markdownlint-cli further pins down the operation.

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 check-only behavior is implied by 'without rewriting files', but no explicit when-to-use guidance or named alternative tools are provided. An agent must infer that rush_markdown is for lint-style checking rather than formatting, without direct comparison to siblings.

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

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

With no annotations, the description carries the full behavioral burden. It discloses only that the lock is non-blocking; it does not explain what happens on contention, whether the lock is reentrant, how ownership is tied to agent_id, or what the return value is.

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 compact single phrase with no filler or redundant sentences. It loses a point because the brevity partly reflects under-specification rather than purely efficient communication.

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 side-effecting lock tool with no annotations and 0% schema descriptions, the description omits critical context: failure behavior, lock scope, lifecycle, and relationship to the release sibling. The output schema may define return shape, but it cannot compensate for missing usage and parameter semantics.

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

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

Schema coverage is 0% and the description does not explicitly define 'path' or 'agent_id'. The phrase 'file lock' weakly implies path is the lock target and 'multi-agent' implies agent_id identifies the holder, but this remains indirect and insufficient for a 2-parameter tool with no 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 states a specific verb ('Acquire') and resource ('non-blocking multi-agent file lock'), making the tool's function immediately clear. It also distinguishes from the sibling rush_mesh_release_lock through the acquire/release opposition.

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?

No guidance is given about when to acquire the lock, when not to, or how this interacts with rush_mesh_release_lock. The 'non-blocking' qualifier vaguely implies behavior under contention but does not state a selection condition or alternative.

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

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

No annotations are present, so the description carries the full burden of disclosing behavior. 'Release' only names the high-level action; it does not say whether the operation is idempotent, whether agent_id ownership is validated, whether the lock is forcibly dropped, or what side effects occur if the caller does not hold the lock.

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 short phrase with no filler, and the action verb is front-loaded. It is efficient, although the brevity sacrifices useful detail; the structure itself is not the issue.

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 state-changing lock operation with no annotations and no parameter descriptions, the definition is incomplete. An output schema exists, so return values may be covered elsewhere, but an agent still lacks prerequisite, ownership, and failure-mode context needed to use the tool confidently.

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

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

Schema description coverage is 0%, and the description does not explicitly define either parameter. The phrase 'multi-agent file lock' hints that path is the lock target and agent_id identifies an agent, but this mapping is left to inference. The description does not compensate adequately for the missing parameter documentation.

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

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

The description uses a specific verb ('Release') and a concrete resource ('multi-agent file lock'), so an agent can tell this tool undoes a lock acquisition and is the counterpart to rush_mesh_acquire_lock. It does not add extra scope or explicitly differentiate from siblings, but the core purpose is 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?

There is no guidance about when to invoke this tool, what conditions must hold before release, or how it relates to acquire_lock beyond the name. No exclusions, prerequisites, or alternative recommendations are provided, so usage must be inferred entirely.

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