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

The description marks the tool as [READ] and describes its output, indicating non-destructive operation. However, no annotations are provided, so the description carries full burden. It does not disclose potential performance impact, authentication needs, or rate limits, but the read-only nature is clear.

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 structured with a clear header, body explaining functionality, an Args section, and a Returns section. It is front-loaded with the purpose but could be slightly more concise; still, every sentence adds value.

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

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

Given no output schema and 0% schema coverage, the description provides a thorough explanation of the tool's behavior, parameters, and return value. It covers the essential aspects for an agent to use it correctly, though it omits error cases.

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

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

The description explains all 5 parameters: old_artifact_days, limit, projects, artifacts_by_project, and target, including their defaults and purposes. This adds significant value beyond the schema, which has 0% description coverage.

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

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

The description clearly states it ranks projects by storage and estimates reclaimable artifact bytes, using specific verbs 'rank' and 'estimate'. It distinguishes from sibling tools like list_artifacts (which only lists artifacts) by focusing on analysis and reclaimability estimation.

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 explains when to use it: for storage bloat analysis, either by providing pre-existing data or pulling live from a target. It does not explicitly exclude alternatives, but the context implies this is for analysis before deletion or cleanup.

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

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

The description discloses the write nature, risk level, prior reading of pipeline state, irreversibility, and dry-run option. No annotations existed to contradict, and the description adds valuable behavioral context.

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

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

The description is well-structured with a tag, concise statement, behavioral paragraph, and parameter list. It is not overly verbose, though the 'Reads the pipeline first' detail could be considered extra.

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 4 parameters, no output schema, and no annotations, the description covers the tool's purpose, side effects, and parameter details adequately. Missing return value info is acceptable due to missing output schema.

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

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

Schema description coverage is 0%, but the description's Args section provides meaningful explanations for all 4 parameters, including project, pipeline, dry_run, and target, which the schema only gives titles and types.

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

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

The description explicitly states 'Cancel a running pipeline' with a specific verb and resource. It clearly distinguishes from sibling tools like retry_pipeline, which retries instead of cancels.

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 context on when to use (cancel a running pipeline) and includes a caution about irreversibility. It does not explicitly mention alternatives but implies the tool is for canceling, which is clear enough.

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

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

Despite no annotations, the description explicitly states the tool is read-only and resilient: a failing sub-call degrades to a partial summary with an 'errors' list. This adds valuable behavioral context beyond typical read operations.

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

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

Three sentences, front-loaded with purpose, then behavioral trait, then parameter. Every sentence adds value without redundancy.

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

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

Given no output schema and one optional parameter, the description sufficiently covers what the tool does, its behavior, and parameter usage. It is complete for its complexity.

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

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

Schema description coverage is 0%, but the description fully explains the single parameter 'target' as a server target name from config, with default behavior. This adds meaning beyond what the schema provides.

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

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

The description clearly states it is a 'one-shot summary' covering version, token identity, projects, and runners. The [READ] prefix and specific components distinguish it from sibling tools, which are more granular (e.g., pipeline_detail, list_runners).

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 implicitly suggests use for a quick high-level overview. However, it lacks explicit guidance on when to use this tool versus more specific siblings or when to avoid 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?

Marks the tool as READ, implying it's non-destructive, but with no annotations the description carries full burden. No mention of authentication requirements, rate limits, or error behavior.

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

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

Two concise lines: first states purpose, second explains parameter. No redundant text, effectively 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?

Sufficient for a simple tool with one optional parameter and no output schema. Covers purpose and parameter semantics, but could hint at return type or authentication 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?

With schema description coverage at 0%, the description adds value by explaining 'target' as a server name from config with a default. Clarifies purpose beyond raw 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?

Clearly states the tool returns the token's identity and frames it as a scope probe. Distinct from sibling tools which focus on pipelines, runners, artifacts, etc.

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

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

Describes the 'target' parameter but does not explicitly state when to use this tool versus alternatives or provide context exclusions. Usage is implied but not exhaustive.

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

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

Despite no annotations, description discloses all behavioral traits: destructive (IRREVERSIBLE), reads artifact inventory, records priorState, supports dry_run. Fully meets transparency requirements.

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

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

Description is well-structured with args section, but slightly verbose. Each sentence is useful, no waste. Front-loaded with purpose and risk.

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

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

Covers purpose, usage, parameters, and destructive behavior. Lacks explanation of return value format and error cases, but given no output schema, it's reasonable. Could be more 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?

With 0% schema description coverage, description provides complete semantics for all 4 parameters: project (id or path), older_than_days (days to filter), dry_run (preview), target (server target). Adds significant value beyond schema.

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

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

Description clearly states the tool deletes project artifacts, with options to delete all or older than N days. It distinguishes from siblings like list_artifacts by explicitly marking as WRITE and high risk.

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

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

Provides clear when-to-use: when deleting artifacts, with dry_run for preview. Mentions irreversibility. Lacks explicit comparison to sibling tools like stale_work_audit, but does warn about destructive nature.

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?

Discloses key behaviors: truncation of earlier lines and byte ceiling, and the meaning of return flags. Since no annotations are provided, the description fully covers transparency.

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

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

Well-organized with a clear header, return value description, and bullet-style args. No unnecessary text; every sentence adds value.

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

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

Completely describes the return object with all fields, explains truncation conditions, and covers all parameters. No output schema exists, so the description fulfills that need thoroughly.

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

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

Despite 0% schema coverage, the description contains an 'Args' section that explains all four parameters, including default values and sources for parameters like job id.

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

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

The description clearly states it is a READ operation retrieving the tail of a job's log/trace, explicitly mentioning the return fields and distinguishing itself from sibling tools like pipeline_failure_rca by focusing on the raw trace tail.

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

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

Provides guidance on when to increase tail_lines if truncated, and indicates how to obtain the job id. While it does not explicitly state when not to use, the context is sufficient for proper tool selection.

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 fully discloses behavioral traits: it explains truncation behavior, that 'totalBytes' etc. count all artifacts even when rows are cut, that 'truncated' indicates subset, and that GitLab's bounded scan may cause 'jobScanTruncated' meaning totals are lower bounds. This provides comprehensive transparency.

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

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

The description is well-structured with a punchy header, a explanatory paragraph, and a bulleted Args list. It front-loads the purpose. While arguably slightly verbose, every sentence adds value, so it is efficient for its complexity.

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

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

Given the tool's complexity (truncation, expiry, GitLab bounded scan) and no output schema, the description provides enough detail about return fields (totalBytes, expiredButKept, etc.) and behavior. It also references a sibling tool (delete_artifacts) for context. No gaps remain for an agent to select and use it correctly.

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

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

Input schema has 0% description coverage, so the description must fully explain parameters. It provides clear, concise descriptions for all three parameters: 'project' (id or path), 'limit' (max rows, default 500), and 'target' (server name, omit for default). This adds essential meaning beyond the schema's titles and types.

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

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

The description starts with '[READ] A project's artifact inventory: files, sizes, expiry', specifying a clear verb ('list'), resource ('artifacts'), and scope (inventory with file details). It distinguishes from sibling tools like delete_artifacts by stating it reports 'delete_artifacts candidates' and from other analysis tools by focusing on listing inventory.

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

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

The description states it is a read operation and gives behavior guidance: totals remain correct when truncated, and a bounded scan means totals are lower bounds. It implicitly distinguishes from delete_artifacts by mentioning candidates, but does not explicitly state when to use this vs. alternatives like artifact_storage_bloat_analysis.

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

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

The description goes beyond schema by disclosing that limit is capped at 99 and the result carries a 'truncated' flag when server has more. No annotations were provided, so this transparency is valuable, though it could mention authorization requirements.

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

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

The description is concise with two clear sentences and a structured args list. Every sentence adds value, 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?

No output schema is provided; description states the tool returns branches with last-commit date and protected flag but does not detail the full output structure or pagination beyond the truncation flag. For a simple listing tool, it is adequate but incomplete.

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

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

With 0% schema description coverage, the description fully explains each parameter: project (id or full path), limit (default 100, capped at 99, truncation behavior), and target (server target, default handled). This adds critical meaning absent from the schema.

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

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

The description clearly states it is a read operation with '[READ]' and specifies the resource (branches) and the returned fields (last-commit date and protected flag). It effectively distinguishes from sibling tool 'list_protected_branches' by implication, as this lists all branches.

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

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

The description explains the tool's functionality but does not explicitly advise when to use this tool over siblings like 'list_protected_branches'. Usage context is implied but not clearly stated.

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

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

The description uses [READ] to indicate non-destructive behavior, explains that state words are translated across platforms, and mentions the 'truncated' field in results when limit is reached. No annotations are provided, so the description carries the burden well, though it could detail more about rate limits or authentication.

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

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

The description is concise: one-line purpose followed by a clear list of parameters. It is front-loaded with the core purpose. Every sentence adds value without redundancy.

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

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

Given 4 parameters, no output schema, and no annotations, the description covers all inputs and some behavioral traits (truncation, state translation). However, it does not explain the output structure or possible error conditions, which would enhance completeness for an AI agent.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining each parameter: project (id or path), state (with translation), limit (default 50, max 99, truncated flag), and target (server config). This adds significant meaning beyond the schema.

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

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

The description clearly states it lists merge/pull requests for a project, with default open ones. The verb 'list' and resource 'merge/pull requests' are specific. Sibling tools like list_pipelines and list_artifacts are distinct, so confusion is unlikely.

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

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

The description explains default state and available states, but does not explicitly compare with sibling tools or state when not to use it. However, sibling tools cover different resources (pipelines, runners), so implicit differentiation is sufficient. A clear alternative or exclusion would raise the score.

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 full burden. It explains return format and truncation behavior in detail ('one extra row is fetched, never guessed'). The '[READ]' prefix implies read-only. It does not mention authentication or rate limits, but for a list tool, this is adequate.

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

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

The description is front-loaded with purpose and return shape, then truncation details, then parameters. It is efficient but could be slightly more compact. Every sentence adds value.

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

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

Despite no output schema, the description outlines the return structure ({project, pipelines, returned, limit, truncated}) and explains truncation. All parameters are documented. For a list tool, this is comprehensive.

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

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

Schema description coverage is 0%, but the description fully explains all four parameters with examples, defaults, and constraints (limit max 99, project path format, status values). This adds significant value beyond the bare schema.

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

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

Description starts with '[READ] Recent pipelines/runs for a project, newest first.' Clearly identifies the verb (list/read), resource (pipelines), and scope (project, sorted). Distinguishes from sibling tools like pipeline_detail and pipeline_jobs by focusing on listing multiple pipelines.

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 guidance on handling truncation ('re-run with higher limit') and explains the truncation detection method. However, it does not explicitly state when to use this tool versus alternatives or when not to use it.

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

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

No annotations provided, so description carries full burden. Discloses return format '{projects:[...], returned, limit, truncated}' and explains 'truncated' meaning server has more projects. Also notes default and max limit. Does not explicitly state idempotency but '[READ]' implies safety.

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

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

Extremely concise with a structured header line then bullet-style args. Every sentence adds value. No fluff. Front-loaded with core purpose.

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

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

No annotations or output schema, but description covers return format, truncation behavior, parameter details, and scope. Provides all necessary information for an agent to invoke correctly.

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

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

Schema coverage is 0%, so description must explain parameters. It does so fully: 'search' as optional name filter, 'limit' with default 50 and max 99, 'target' as server target with default omit. All three parameters are clearly described.

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

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

Starts with '[READ] Projects/repositories the token can see', clearly identifying a read operation on projects. Mention of 'with storage numbers' adds specificity. Distinguishes from siblings like 'project_detail' (single project) and 'list_pipelines' (different resource).

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

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

States it lists projects visible to the token, implying scope but does not explicitly provide when to use vs. alternatives. No mention of when not to use or comparison with siblings like 'project_detail'. Lacks 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 full burden. It discloses the read-only nature via '[READ]' and describes the return structure. It adds context about force-push flags being included. However, it does not mention auth requirements or potential side effects, which are minor for a read tool.

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

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

The description is concise, front-loaded with purpose and read flag, and includes only necessary information. The structure is clear: one line for purpose, one for return type, then parameter descriptions. No wasted words.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description is complete. It covers purpose, parameter details, and return structure. The mention of 'limit' and 'truncated' addresses pagination. No additional context needed for 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?

The description provides parameter semantics via an 'Args' section that explains each of the three parameters (project, limit, target) in detail, including default values. The input schema has no property descriptions, so the description fully compensates with high coverage.

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

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

The description clearly states 'Branch-protection rules for a project (incl. force-push flags),' specifying both the resource and scope. This distinguishes it from siblings like list_branches (which lists branches, not protection rules) and update_branch_protection (which modifies).

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?

While the purpose is clear, there is no explicit guidance on when to use this tool versus alternatives. The description does not mention exclusions or provide comparisons with siblings like list_branches or update_branch_protection. Usage is implied but not explicitly clarified.

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

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

With no annotations, the description carries full burden. It indicates the operation is read-only via '[READ]', describes ordering and truncation behavior for limit, but does not disclose authentication needs, rate limits, or potential side effects on the system.

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

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

The description is extremely concise: three lines covering purpose, parameters, and behavior. No redundant wording; every sentence adds value and is front-loaded with the key purpose.

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

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

Given 3 parameters, no output schema, and no annotations, the description covers the essential aspects: purpose, required param, limit behavior, and target. It mentions the 'truncated' indicator and defaults. While it could elaborate on return format, it is largely adequate for a list tool.

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

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

Schema description coverage is 0%, so the description must add meaning. It specifies 'project' as id or full path, 'limit' with max 99 and truncation indicator, and 'target' as server target name with default behavior. This adds significant context beyond the schema's type 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 clearly states the verb ('list'), resource ('releases'), scope ('for a project'), and ordering ('newest first'), effectively distinguishing it from sibling tools like list_artifacts or list_pipelines.

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

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

The description explains the required 'project' argument and details the 'limit' and 'target' parameters, but does not explicitly state when to use this tool over siblings or provide context for exclusion criteria. Usage is implied by resource name but lacks direct 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 discloses important behavioral traits: it is a READ operation, returns a specific structure, sorts offline/paused first, caps limits at 99, and raises a teaching error for Gitea. Lacks details on authorization or rate limits but sufficiently warns about non-broken error.

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

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

Well-structured: starts with a one-line summary, then platform note, return format, and args. Every sentence adds value. Could be slightly more concise but no waste.

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

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

Given no output schema and no annotations, the description covers return structure, sorting, platform limitation, and parameter details. Missing error scenarios beyond Gitea, but overall adequate for a list tool.

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

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

Schema coverage is 0%, but the description adds meaning for all three parameters: status (possible values), limit (default and cap), target (server target). This compensates well for the missing schema descriptions.

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

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

The description clearly states it lists all runners visible to the token, with sorting behavior (offline/paused first). It distinguishes from sibling tools like runner_detail and runner_health_rca by indicating it's a broad list, not a detail or health analysis. The platform restriction (GitLab only) is explicit.

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

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

Provides clear context: use for listing all runners, with platform-specific guidance (Gitea yields a teaching error). Does not explicitly contrast with alternative list tools but implies its unique scope. The 'do not retry' instruction for Gitea is helpful.

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

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

No annotations provided, so description carries full burden. It discloses it's a write operation with [risk=medium], explains it reads the runner first to record prior state, and describes effects clearly.

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

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

Well-structured summary, behavioral notes, and parameter list. Every sentence adds value; 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?

Covers purpose, effects, and parameters thoroughly. Lacks description of return value, but no output schema exists. Slight gap in completeness.

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

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

With 0% schema coverage, description fully explains each parameter: runner is an ID from list_runners, dry_run previews without pausing, target is a server config name with a default.

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

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

The description clearly states 'Pause a runner' and explains it is reversible via undo, distinguishing it from the sibling resume_runner.

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

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

Provides context on when to use: to stop a runner from picking new jobs while letting running jobs finish. Mentions dry_run for preview. Could be more explicit about alternatives, but sibling list includes resume_runner.

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 '[READ]' prefix indicates a non-destructive operation, which is helpful. However, no annotations are provided, and the description lacks details about what 'full detail' includes (e.g., fields, pagination). Behavior is minimally transparent but not misleading.

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

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

The description is extremely concise: a two-line summary followed by a bullet-point parameter list. No redundant sentences. Front-loaded with purpose.

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

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

For a simple read tool with no output schema and three parameters, the description covers purpose and parameters adequately. It lacks details about the return format (e.g., JSON structure), but this is acceptable given the simplicity.

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

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

The schema has 0% coverage (no descriptions), so the description must compensate. It provides clear explanations: 'project' is id or full path, 'pipeline' is id from list_pipelines, 'target' is optional server name. This adds significant meaning beyond the schema.

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

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

The description clearly states '[READ] One pipeline/run's full detail,' which is a specific verb+resource. It distinguishes from sibling tools like 'list_pipelines' (list all) and 'pipeline_failure_rca' (root cause 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 description explains the parameters, noting that 'pipeline' comes from 'list_pipelines', which provides usage context. However, it does not explicitly state when to use this tool versus alternatives like 'pipeline_failure_rca'.

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

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

The description opens with '[READ]', indicating a non-destructive operation. It details that it pulls live data and classifies failures with evidence, but does not mention required permissions or side effects. Given no annotations, this is adequate.

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

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

The description is somewhat lengthy but well-structured with a concise intro, a detailed functional paragraph, bulleted Args, and return spec. It front-loads the verb and purpose, avoiding unnecessary 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?

Despite no output schema, the description details the full return dict structure (pipelinesEvaluated, classCounts, pipelines with nested failedJobs, etc.) and explains classification categories and evidence. This makes it complete for the tool's complexity.

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

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

With 0% schema description coverage, the description fully explains all 5 parameters (project, limit, tail_lines, failed_pipelines, target) with their types, defaults, and relationships (e.g., 'required unless failed_pipelines given'). This comprehensively compensates for the schema gap.

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

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

The description clearly states the tool classifies recent failed pipelines to provide cause and action per pipeline. It uses specific verbs like 'classify' and 'pulls', and the 'flagship pipeline RCA' distinguishes it from sibling tools like list_pipelines.

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

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

The description explains two usage modes: passing 'failed_pipelines' for pure analysis or a project to pull live. It also notes the 'project' is required unless 'failed_pipelines' is given. However, it does not explicitly contrast with sibling tools or state when not to use.

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

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

The description starts with [READ] indicating read-only, and explains the return structure including truncation behavior. No annotations exist, so the description carries the burden. It does not disclose authentication needs, rate limits, or error conditions, but it covers key behavioral aspects for a listing tool.

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

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

The description is concise and well-structured, starting with the purpose, then the return format, and finally an Args list. It is front-loaded and avoids unnecessary repetition, though it could be slightly shorter without loss of 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?

Given no output schema, the description explains the return structure (project, pipeline, jobs, returned, limit, truncated) and mentions truncation. This is sufficient for a job-listing tool, though it omits details like job fields and error handling.

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 0% description coverage, but the description provides clear explanations for all four parameters: project (id or full path), pipeline (from list_pipelines), limit (default 100), and target (server target from config). This adds meaning beyond the schema's type/default.

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

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

The description clearly states it returns jobs of a pipeline/run with status and failure reason. It distinguishes from siblings like list_pipelines and pipeline_detail by focusing on jobs. However, it does not explicitly differentiate from job_trace_tail or other job-related 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 usage: when you need jobs of a specific pipeline. It mentions the relationship to list_pipelines (pipeline id from there). It does not provide explicit when-not-to-use or alternatives among siblings, leaving the agent to infer.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only indicates a read operation via '[READ]' but does not specify permissions, side effects, or any constraints. The agent lacks safety information beyond the read hint.

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

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

Extremely concise with no unnecessary words. Uses a structured 'Args:' format to present parameters efficiently. Every sentence is valuable.

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

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

The description mentions inclusion of byte counts but does not fully describe the return value. Since there is no output schema, a more complete description of the response would be beneficial. The current description is adequate but not comprehensive.

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, but the description fully compensates by explaining both parameters: project (id or full path with examples) and target (server target, optional with default). This adds clear meaning beyond the bare 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?

Clearly states it reads one project's details including repo/artifact byte counts. The verb 'detail' and resource 'project' are specific, and the inclusion of byte counts distinguishes it from sibling tools like list_projects.

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 it is for retrieving details of a single project but provides no explicit when-to-use or when-not-to-use guidance. No comparison to alternatives like pipeline_detail or list_projects is given, leaving the agent to infer 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?

With no annotations, the description carries the full burden. It discloses that this is a WRITE operation with medium risk, reads the runner first, and is reversible via undo. It also mentions the dry_run preview. This adds good behavioral context, though it lacks details on authentication or rate limits.

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

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

The description is concise with a clear structure: a single-line summary (with risk flag), a brief behavioral note, and an Args list. Every sentence serves a purpose 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?

For a tool with 3 parameters and no output schema, the description covers safe usage, reversibility, and parameter details. It does not describe what the resumption entails (e.g., state changes) or the return value, but the information provided is sufficient for most use cases.

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 explain all parameters. It does so effectively: runner is described as 'Runner id (from list_runners)', dry_run as 'preview without resuming', and target as 'Server target name from config; omit for default'. This adds substantial meaning beyond the schema.

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

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

The description clearly states the tool resumes a paused runner. It mentions reversibility and uses a specific verb-resource pair. However, it does not explicitly differentiate from sibling tools like pause_runner or list_runners, though the action is distinct.

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

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

The description provides some usage context: it reads the runner first to record prior state for undo, and offers a dry_run flag to preview. It implies when to use (when runner is paused) but does not explicitly state when not to use or mention 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 provided, so description carries full burden. It discloses that the tool reads the pipeline first to record prior status, is irreversible, and offers a dry-run option. This provides strong behavioral transparency.

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

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

Front-loaded with [WRITE][risk=medium], followed by a clear one-sentence summary. Parameter descriptions are listed concisely. Every sentence adds value with no wasted words.

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

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

For a retry operation with no output schema, the description covers essential context: state recording, irreversibility, dry-run, parameter details. It is complete for the tool's complexity.

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

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

With 0% schema coverage, description fully explains all parameters: project (id or full path), pipeline (id from list_pipelines), dry_run (preview), target (server target from config). Adds significant meaning beyond the schema.

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

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

The description clearly states it retries a failed/canceled pipeline, using specific verb and resource. It distinguishes from siblings like cancel_pipeline which cancels, and undo_apply which undoes.

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 indicates use when pipeline is failed/canceled and mentions dry_run for preview. It does not explicitly state when not to use or list alternatives, but the context is clear enough.

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

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

No annotations provided, so description carries full burden. It uses '[READ]' to hint at read-only. It mentions that using a Gitea target causes an error. For a simple read tool, this is adequate but does not disclose any potential side effects, performance, or caching behavior.

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

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

The description is extremely concise: one line for purpose, one line for GitLab-only constraint, then two lines for parameter details. Front-loaded with '[READ]'. Every sentence earns its place.

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

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

Given the tool has only 2 parameters and no output schema, the description is complete. It lists the fields returned (contacted_at, tags, paused, version) and explains both parameters. No missing information for a simple retrieval tool.

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

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

Schema description coverage is 0%, so description must compensate. It explains 'runner' as 'Runner id (from list_runners)' and 'target' as 'Server target name from config; omit for the default.' This adds clear meaning beyond the schema, which has no descriptions.

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

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

The description clearly states it reads one runner's full detail and lists specific fields (contacted_at, tags, paused, version). It distinguishes from siblings like list_runners and pause_runner/resume_runner by specifying it is a read operation on a single runner. Also notes GITLAB ONLY, which sets scope.

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 good guidance by noting 'GITLAB ONLY — a Gitea target raises the same teaching error as list_runners', explicitly telling the agent when not to use. It also explains parameter usage (target optional, default). However, it does not explicitly compare to siblings like runner_health_rca, though the purpose is different enough.

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

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

The description explains the analysis algorithm (flagging offline/stale/paused runners, queued jobs, tag saturation) and the return dict structure. With no annotations, it carries the burden well but omits potential behaviors like authentication requirements or error scenarios.

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?

Front-loaded with a concise summary, followed by a brief algorithm explanation and structured Args list. Could be slightly more concise but every sentence adds value.

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

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

Covers all input parameters and high-level output structure, but lacks details on exact return fields (e.g., 'note' content) and error handling. No output schema provided.

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

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

Schema description coverage is 0%, but the description's Args section provides clear explanations for each parameter (e.g., 'stale_contact_min: Minutes since last contact at which a runner is stale'). Adds significant meaning beyond the schema's property titles.

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?

Starts with '[READ] Flag offline/stale/paused runners, long-queued jobs, tag saturation' which clearly states the verb and resource. Positions itself as 'the flagship capacity RCA', distinguishing from sibling tools like list_runners and runner_detail.

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

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

Provides clear usage context: explains when to pass 'runners'/'queued_jobs' for analysis vs a target for live pull. However, lacks explicit when-not-to-use or alternative recommendations.

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

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

No annotations provided, so description carries full burden. It only states '[READ]' hinting at read-only, but does not explicitly confirm no side effects, idempotency, or safety guarantees. Minimal 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?

Extremely concise: two short sentences plus a clear argument list. No redundant information, front-loaded with purpose.

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

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

No output schema, so description could elaborate on return format (e.g., version string, revision). Also, the parameter 'target' suggests multiple servers but not how to configure or list targets. Adequate for simple tool but room for improvement.

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

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

Schema has 0% description coverage, but the description adds meaningful context: 'target: Server target name from config; omit for the default.' This clarifies the parameter's purpose and usage beyond the schema type.

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

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

The description clearly states it returns CI/CD server version and revision, using a prefix '[READ]' to indicate the action. It distinguishes from siblings that focus on pipelines, runners, artifacts, etc.

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

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

No guidance on when to use this tool versus alternatives. Siblings include many read tools like list_*, and the description does not mention any specific context 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?

The description upfront declares the tool is a '[READ]' operation, indicating no mutation. It explains that it 'flags' issues and returns a dictionary with specific keys like count and thresholds. Since no annotations are provided, this description adequately discloses the tool's behavior and what the output contains.

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

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

The description is concise yet comprehensive, front-loading the purpose and then detailing parameters and return format. Every sentence serves a purpose, and the structure with paragraphs and bullet-like lists makes it easy to scan. No unnecessary words.

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

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

For a complex audit tool with 8 parameters and no output schema, the description covers the input, logic, and output thoroughly. It explains the relationship between injected vs live data. Minor omissions like error handling or performance notes do not detract significantly from overall completeness.

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

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

With 0% schema coverage, the description does heavy lifting. It explains each parameter's purpose, defaults (e.g., stale_mr_days=14), and how injected rows should be structured (fields like id, title, updatedAt, draft). The 'target' parameter is only briefly described, but overall the description adds significant meaning beyond the raw 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 begins with '[READ] Long-open MRs/PRs, inactive branches, protection config gaps.' which clearly states the tool's function as an audit. It details what it flags (stale merge requests, inactive branches, protection gaps), distinguishing itself from sibling list tools by performing analysis rather than simple retrieval.

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

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

The description explicitly explains two usage modes: 'Pass injected rows for pure analysis, or a project to pull live.' It emphasizes that project is required unless rows are injected, providing clear context for when to use each parameter. However, it does not explicitly state when not to use this tool or compare it to alternatives.

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

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

With no annotations, the description carries full burden. It discloses dispatching the inverse tool, the governed execution, dry-run preview, and one-time token use. Lacks explicit mention of side effects like token consumption or error handling, but covers key behaviors.

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?

Five sentences with clear structure: purpose statement, behavioral details, parameter list. Front-loaded with '[WRITE][risk=medium]'. Every sentence adds value without redundancy.

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

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

Describes parameters and overall mechanism, but lacks output description or error conditions. With no output schema, the agent is left guessing the return value. Adequate for a simple tool but not fully complete.

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

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

Schema coverage is 0%, so description must compensate. It explains each parameter: undo_id source, dry_run purpose, and target pass-through. Adds meaningful context beyond schema types and defaults.

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

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

The description clearly states it applies a recorded undo by dispatching its inverse tool. It references undo_list as the source of undo IDs, distinguishing it from listing tools and other mutation tools like retry_pipeline or cancel_pipeline.

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

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

Provides context for use: apply undo from undo_list, preview with dry_run, and notes that each token can only be applied once. Does not explicitly list when not to use or alternatives, but the implicit guidance is sufficient.

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 fully discloses behavior: it is a read operation, returns a structured response with truncation details, and explains the 'effectVerified' field meaning. No contradictions exist.

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

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

The description is well-structured with sections for summary, return format, and args. Every sentence is informative, though slightly verbose in the truncation explanation. Still, it is efficient 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?

Given no output schema, the description covers the return structure (undos, returned, limit, truncated) and important field 'effectVerified'. Parameters are fully described, and sibling tools provide related context.

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

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

Despite 0% schema coverage, the description explains both parameters: 'limit' with default/max and 'target' as unused for CLI uniformity. This adds significant 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 begins with '[READ] List recorded, not-yet-applied undo tokens (most recent first)', which is a specific verb+resource statement. It distinguishes the tool from its sibling 'undo_apply' by stating the list provides undoId for that 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?

The description explicitly says 'Use the undoId with undo_apply', guiding the agent to the next action. It also notes that the 'target' parameter is unused, preventing misuse. The context of listing pending tokens before applying an undo is clear.

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

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

With no annotations, the description fully discloses behavioral traits: it is a write operation with medium risk, it reads current protection first for undo capability, and provides a dry-run option for preview. It also notes reversibility. This is exemplary disclosure beyond what structured data provides.

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

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

The description is concise and well-structured: front-loaded with key info ('[WRITE][risk=medium] Protect/unprotect a branch; reversible.'), followed by essential context about undo, then a clear Args list. Every sentence adds value 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?

Given the tool's complexity (6 parameters, no output schema), the description covers behavior, parameters, and side effects well. However, it omits details about the return value or status upon success/failure. This is a minor gap but does not hinder 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 carries full burden. The Args section adds meaningful explanations for each parameter (e.g., 'protect: True to protect, False to remove', 'allow_force_push: default False — the safe setting'), which greatly aids understanding beyond the schema's type/default.

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

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

Description explicitly states the verb and resource: 'Protect/unprotect a branch'. It is clear and distinguishes itself from sibling tools like list_protected_branches, which only read. The reversible nature and undo mechanism further clarify its unique purpose.

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

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

The description implies when to use (to change branch protection) and provides context like dry_run for preview. However, it does not explicitly state when not to use or provide alternatives, though no direct alternatives exist among siblings. The guidance is clear but not exhaustive.

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