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

No annotations are provided, and the description does not disclose behavioral traits such as authentication requirements, rate limits, or whether the comment is appended. Merely states the action without additional 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 a single sentence that front-loads the core purpose without any filler. 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?

The tool has an output schema (known from context) and a simple action. However, the description lacks usage context like prerequisites or examples. It is minimally complete but could benefit from additional guidance.

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

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

All parameters have descriptions in the input schema (100% coverage). The description does not add extra meaning beyond what the schema provides; hence baseline score of 3.

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

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

The description clearly states the verb and resource: 'Create a comment on a GitHub issue or pull request.' It distinguishes this tool from sibling tools that are read-only (get, list, search).

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 explicit guidance on when to use or not use this tool, nor alternatives mentioned. However, the purpose is implied from the context of sibling tools being read-oriented.

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 behavioral burden. It discloses that the tool mutates state (creates an issue), but it does not mention required auth/permissions, whether the operation is idempotent, API rate-limit implications, or what the response contains. With no annotations and no behavioral detail beyond 'create', this is a notable gap.

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?

One clear, front-loaded sentence with no filler. It earns its place by stating the primary action and target, though it could briefly mention mutation or required fields without adding bulk.

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 has a straightforward purpose and a complete schema, plus an output schema, so an agent can likely invoke it correctly. However, with no annotations and no description of behavioral context (permissions, response, or error cases), the description is only minimally viable rather than 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 description coverage is 100%, so the schema already documents all parameters including defaults and the owner fallback. The description adds no additional parameter meaning beyond the schema, which matches the baseline of 3 for 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 states a clear verb+resource: 'Create a new issue in a GitHub repository.' This distinguishes it from sibling tools like get_issue_tool, list_issues_tool, and update_issue_tool, though it does not explicitly name them. It is specific enough for an agent to know the core action.

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

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

The description implies usage context (creating a new issue) but provides no explicit guidance on when to choose this over update_issue_tool or create_issue_comment_tool. The schema adds helpful defaults (e.g., owner defaults to GITHUB_DEFAULT_ORG), but the description itself offers no 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?

With no annotations, the description carries full burden. It discloses that content is decoded text but does not mention potential issues like large file handling, rate limits, or authentication. Basic transparency is provided but not comprehensive.

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 is front-loaded and contains no superfluous information. Every word is necessary.

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

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

The description is adequate for a simple file retrieval tool, but given the presence of an output schema and sibling tools, it could improve by noting return format or edge cases. Completeness is moderate.

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

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

Schema coverage is 100% with clear parameter descriptions. The tool description does not add additional meaning beyond the schema, so baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves decoded text content of a file in a GitHub repository. The verb 'get' and resource 'file content' are specific. It distinguishes itself from sibling tools like get_pull_request_diff_tool (diff) and search_code_tool (search).

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 raw file content is needed but provides no explicit guidance on when to use this tool over alternatives like get_pull_request_diff_tool or list_repo_tree_tool. No exclusions or conditions are mentioned.

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

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

With no annotations, the description's single sentence does not disclose behavioral traits beyond the basic operation. It fails to mention that this is a read-only operation, any rate limits, or error responses, which are important for safe invocation.

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, consisting of one clear sentence that immediately conveys the tool's purpose. Every word is necessary and there is no redundant information.

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

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

Given the tool's low complexity and the presence of a complete output schema and parameter documentation, the brief description is minimally adequate. However, it could benefit from specifying the scope (e.g., 'from the specified repository') and any prerequisites (e.g., authentication).

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

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

Schema description coverage is 100%, so the description adds no extra meaning beyond what the schema already provides for repo, issue_number, and owner parameters. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: retrieving a single GitHub issue by number. It uses a specific verb ('Get') and resource ('GitHub issue'), and implicitly distinguishes from sibling tools that list or search issues.

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 on when to use this tool versus alternatives (e.g., list_issues_tool, search_issues_tool). There are no explicit conditions or exclusion criteria, leaving the agent to infer usage 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 must carry the burden of behavioral disclosure. It discloses the classification logic (passed, failing, pending, skipped), explicitly states that SKIPPED is not a failure, and explains the semantics of ready_to_merge (true only when nothing is failing/pending and PR is not known-unmergeable). This gives the agent a clear model of the tool's behavior. It does not discuss edge cases (e.g., no checks) or potential side effects, but for a read-only tool this is acceptable.

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

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

The description is two sentences, front-loading the primary purpose and then adding a concise clarification. It is free of fluff and every sentence contributes meaningful information: the main action and the critical interpretation of the boolean. Excellent 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?

Given the presence of an output schema (not shown but indicated), the description does not need to describe the return type in detail. It explains the most important output field (ready_to_merge) and its semantics. For a tool with 3 parameters, all fully described in the schema, and a clear behavioral contract, the description is complete enough. A minor gap is not stating what happens when there are no checks, but that is a minor edge case.

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

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

Schema description coverage is 100%, so the description adds little beyond what the schema already provides. The description does not elaborate on parameter meaning (e.g., how repo and pull_number are used), but the schema is explicit. There is no requirement for the description to compensate here, so a baseline 3 is appropriate.

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

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

The description states a clear action ('Get a CI verdict') and a specific resource ('a PR'), and explicitly distinguishes its purpose from a generic check by highlighting the skipped-vs-failed distinction. It also names the key output (ready_to_merge), so an agent knows exactly what the tool provides. This clearly sets it apart from sibling tools like list_workflow_runs_tool or get_pull_request_diff_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 gives concrete guidance on how to interpret the result (use ready_to_merge as the merge signal). It implies the proper context of use (evaluating CI status) but does not explicitly contrast with alternatives or state when not to use it. For a read-only tool with a distinct purpose, this is sufficient 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?

No annotations are provided, and the description fails to disclose behavioral traits such as read-only nature, auth requirements, rate limits, or output size limits. The description does not compensate for the lack of annotations.

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

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

The description is a single clear sentence with no extraneous information. However, it could be slightly improved by adding a sentence about output format or usage context without becoming verbose.

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

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

The description is minimal but an output schema exists (reducing the need to explain return values). However, for a tool that fetches potentially large diffs, it could mention truncation or format. Overall adequate but not 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 100% schema description coverage, the parameters are already well-documented. The description adds no extra meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action 'Get' and the specific resource 'unified diff for a GitHub pull request'. It distinguishes from sibling tools like get_pull_request_tool (which returns PR metadata) and get_pull_request_checks_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?

No guidance on when to use this tool versus alternatives. Sibling tools exist for similar tasks (e.g., get_pull_request_tool, get_pull_request_checks_tool) but no comparison or context is 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?

No annotations are provided, so the description carries the burden. The verb 'Get' implies a read-only operation, but the description does not disclose further behavioral traits such as rate limits, error handling, or response structure. The presence of an output schema mitigates some need, but the description adds minimal behavioral context beyond the obvious.

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 single sentence (8 words) that front-loads the verb and object. Every word earns its place; 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 simple retrieval tool with a comprehensive output schema, the description is largely sufficient. It could mention that the 'owner' parameter defaults to a configured organization, but overall it provides enough context for an agent to 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?

Schema coverage is 100% with descriptions for all three parameters. The tool description adds no additional meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Get'), the resource ('single GitHub pull request'), and the identifier ('by number'). It is specific and easily distinguishes from sibling tools like list_pull_requests_tool (multiple) or get_pull_request_diff_tool (specific part).

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: it retrieves a single pull request by number. However, it does not provide guidance on when to use this tool versus alternatives (e.g., use get_pull_request_checks_tool for checks), nor does it mention prerequisites or exclusions.

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

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

Description does not disclose behaviors beyond excluding PRs (e.g., pagination, rate limits, sorting). Since no annotations are provided, the description could offer more 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?

Single sentence, concise and to the point, with no superfluous 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?

Given full schema coverage and output schema, the description adequately communicates the tool's scope (issues only). Slight lack of ordering/sorting defaults, but acceptable.

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

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

Schema coverage is 100% with parameter descriptions, so the description adds minimal value beyond what is already in the schema.

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

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

Description clearly states the tool lists issues for a GitHub repository and explicitly excludes pull requests, distinguishing it from list_pull_requests_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?

No explicit guidance on when to use this tool vs alternatives like search_issues_tool. Usage is implied but not 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 the full burden. It only says 'list', implying read-only behavior, but does not disclose details like authentication requirements, rate limits, or that it supports pagination. The output schema provides return structure, so a baseline of 3 is reasonable.

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 sentence with no fluff. However, it could include a bit more context (e.g., filtering options) without losing conciseness.

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 presence of an output schema and complete parameter descriptions, the description is minimally adequate. However, it lacks context about when to use this tool over similar list tools (e.g., list_issues_tool) and does not mention any behavioral constraints.

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?

All 5 parameters are described in the input schema (100% coverage), so the description adds no additional semantic value beyond what's in the schema. The baseline of 3 applies as per guidelines.

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' and resource 'pull requests' with scope 'for a GitHub repository'. It is direct and unambiguous, but does not differentiate from sibling tools like 'get_pull_request_tool' which retrieves a single PR.

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

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

The description provides no guidance on when to use this tool vs alternatives such as search_issues_tool or list_issues_tool. It lacks any mention of when not to use it or prerequisites, leaving the agent to infer from the name alone.

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

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

With no annotations, description bears full burden for behavioral disclosure. Only states what the tool does, not how it behaves (e.g., error handling, authentication, rate limits, output structure). Lacks context beyond minimal functionality.

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

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

Single sentence, no wasted words. Front-loaded with verb and resource. Appropriate length for a straightforward listing tool.

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

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

Given that output schema exists and parameter documentation is thorough, this description is adequate but minimal. Fails to mention key behavioral aspects like recursion or tree types. Agent may need to rely on schema entirely 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 100%, so baseline is 3. Description adds no extra meaning beyond the schema's parameter descriptions. Does not elaborate on defaults or usage of tree_sha or recursive.

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 verb 'List' and resource 'git tree (files and directories)' of a GitHub repository. It is specific and distinct from sibling tools like get_file_content_tool which retrieves a file, and search_code_tool which searches code.

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. Does not mention prerequisites, exclusions, or typical scenarios. Implies usage only through name and description.

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 conveys a non-mutating operation via 'List', and there are no annotations to contradict. With no annotations, the description carries more burden, but it leaves behavioral details like default owner resolution, pagination, and filter behavior to the schema and output schema rather than disclosing them in prose.

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 concise sentence with no filler. It front-loads the action and resource, making it immediately scannable and 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?

The schema and output schema provide the parameter details and result shape, so the tool is callable from the one-line description. However, it omits prose-level context about optional filtering, pagination, and how it relates to the workflow siblings, making it only minimally 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 description coverage is 100%, so all six parameters already have meaningful documentation for filters, pagination, and owner default. The description adds no new parameter semantics; it only reinforces that 'repo' is the core scope.

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 ('List') and a clear resource ('GitHub Actions workflow runs') scoped to 'a repository', so an agent can tell what the tool does. It is distinguishable from siblings like trigger_workflow_tool and rerun_workflow_run_tool by the read-only listing action, though it does not explicitly name alternatives.

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 verb 'List' implies the tool is for retrieving existing workflow runs, which gives some usage context. However, it does not explicitly state when to prefer this tool over trigger/rerun alternatives, nor does it mention any 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 provided, so the description carries the full burden of behavioral disclosure. It reveals that only failed jobs are rerun, but it does not mention side effects (e.g., new job attempts), required permissions, rate limits, or any operational caveats. This is a re-run/mutation action that deserves more transparency.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. It states the core behavior immediately and avoids any unnecessary words.

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

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

For a simple tool with full parameter coverage and an output schema, the description covers the essential behavior. However, it lacks any mention of when to prefer this over the sibling rerun_workflow_run_tool, and with no annotations, it does not provide the operational safety or permission context expected of a mutation tool.

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

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

With 100% schema description coverage, all three parameters (repo, owner, run_id) are already thoroughly documented. The description adds no parameter-specific details, but the schema fully compensates; baseline 3 is appropriate.

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

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

The description clearly states a specific verb ('re-run'), resource ('failed jobs in a GitHub Actions workflow run'), and inherently distinguishes from the sibling rerun_workflow_run_tool by limiting scope to failed jobs. An agent can easily understand what this tool does and how it differs.

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 usage context—when you want to rerun only failed jobs—but it does not explicitly mention alternatives, exclusions, or criteria for choosing this tool over rerun_workflow_run_tool. The guidance is present but 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?

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Re-run all jobs' implies a mutating operation that triggers a new workflow run, but the description does not state permissions required, state requirements for the run, or side effects (e.g., cost, new run creation). This is a minimal disclosure typical of a mutation 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, concise sentence that immediately conveys the action and scope. There is no extraneous information, and the core purpose is front-loaded. This is an efficient use of 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?

The description is minimal and lacks context about when to invoke this tool, its permissions, or the state of the workflow run required for a successful rerun. Although the output schema exists, the absence of annotations and usage guidance leaves the description thin for a mutating operation. Given the low complexity, it is borderline, but the missing operational context makes it 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?

All three parameters are documented in the schema with descriptions, and the tool description does not add additional parameter guidance. The phrase 'all jobs' clarifies the effect on the run, but it does not explain how to format repo, owner, or run_id beyond what the schema already says. With 100% schema coverage, this is adequate but not enhanced.

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 a specific action ('Re-run') on a specific resource ('GitHub Actions workflow run') and specifies scope ('all jobs'). This distinguishes it from the sibling rerun_failed_jobs_tool, which implies a narrower scope of only failed jobs. The verb and resource are unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention the distinction from rerun_failed_jobs_tool or any conditions under which one should be chosen over the other. An agent must infer usage from the sibling tool names, which is not provided by the description.

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, and the description does not disclose behavioral traits such as rate limits, authentication requirements, or response structure. The presence of an output schema is not mentioned in the description.

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

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

Two concise sentences, the first clearly stating the purpose, the second adding essential syntax context. No extraneous 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?

The description is adequate for a simple search tool with an output schema, but lacks usage guidelines and behavioral details that would make it complete for agent decision-making.

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 covers 100% of parameters, so baseline is 3. The description adds value by referencing GitHub code search syntax, which helps agents formulate queries, but does not elaborate on each parameter 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?

Clearly states 'Search for code across GitHub', which is a specific verb and resource. Distinguishes from sibling tools like search_issues_tool by focusing on code search.

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?

Mentions GitHub code search syntax but provides no guidance on when to use this tool versus alternatives (e.g., search_issues_tool). No explicit when-to-use or when-not-to-use 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?

Without annotations, the description covers the key behavior: searching issues and PRs with search syntax. It does not mention rate limits or authentication, but the output schema exists to describe return values.

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

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

Two sentences efficiently convey the tool's purpose and usage without 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?

Given the output schema and clear description, the tool is well-specified for an agent to decide when to invoke it. Could mention that it searches both issues and PRs explicitly, which it does.

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

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

Schema coverage is 100% (baseline 3). The description adds value by explaining the search syntax for the query parameter, which is crucial for correct usage.

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

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

The description clearly states the tool searches for issues and pull requests across GitHub using search syntax, distinguishing it from siblings like list_issues_tool and search_code_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 provides context on using GitHub issue search syntax with an example, implying when to use it. However, it does not explicitly list alternatives or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool starts a brand-new run regardless of when the workflow last ran and that the workflow must declare a workflow_dispatch trigger. However, it does not mention potential side effects like cost, rate limits, or error handling if the prerequisite is not met. Still, it adds meaningful behavioral context 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 concise and well-structured: it opens with the primary action, then contrasts with the alternative, and closes with the prerequisite. Every sentence serves a purpose, and the key information is front-loaded.

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

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

Given that an output schema exists and the input schema fully covers parameters, the description provides the essential use-case differentiation, the prerequisite, and enough context for an agent to decide when to invoke it. It could mention failure modes (e.g., if workflow lacks the trigger), but this is not critical given the schema and the explicit prerequisite statement.

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

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

Schema coverage is 100%, so the baseline is 3. The description does not elaborate on individual parameters but implies that the workflow_id must correspond to a workflow with a workflow_dispatch trigger. It adds minimal extra meaning beyond what the schema already documents.

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 (trigger) and resource (fresh GitHub Actions run) via the workflow_dispatch event, and explicitly contrasts with the sibling rerun_workflow_run_tool to prevent confusion. It is clear and distinguishes from alternatives.

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 contrasts with rerun_workflow_run_tool, explaining when to use this tool (for a new run regardless of last run time) versus re-running an existing run (which is limited to 30 days). It also states the prerequisite that the target workflow must have an on: workflow_dispatch trigger, giving clear when-to-use guidance.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose the key mutation behavior around closing and reopening an issue, which is meaningful. It does not mention permissions, idempotency, label replacement behavior, or other side effects, so it is adequate but not rich.

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

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

The description is two sentences with front-loaded purpose and no filler. The second sentence provides essential state-transition details that directly help the agent call the tool correctly.

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 an 8-parameter mutation tool with full schema coverage and an output schema present, the description covers the non-obvious state behavior well. It is complete enough to invoke correctly, though it would benefit from guidance on alternatives.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds extra semantics by explaining the state/state_reason combination for closing versus reopening. It does not elaborate on title, body, or labels, but those are already described in 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 and resource: 'Update a GitHub issue' and explicitly scopes to closing/reopening. It is clear what the tool does, though it does not explicitly differentiate from the sibling update_pull_request_tool or mention when to choose this over create/update alternatives.

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 concrete how-to guidance for state transitions: 'Set state="closed" to close an issue' and 'Set state="open" with state_reason="reopened" to reopen.' However, it does not state when to use this tool versus siblings like create_issue_tool or update_pull_request_tool, so the usage context is mostly implied.

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

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

With no annotations provided, the description must carry the burden of behavioral disclosure. It does disclose a key non-obvious behavior (does not merge) and gives a concrete example of closing. Yet it omits other relevant behaviors like whether changes are reversible, permission requirements, or effects on CI/notifications. The description adds some value but is not extensive.

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 at two sentences, with the core purpose stated first and the critical 'not merge' caveat immediately following. It avoids redundancy and front-loads the most important information, making it easy for an agent to parse quickly.

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

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

Given the tool's complexity (6 parameters, mutation behavior) and absence of annotations, the description covers only the essential distinction (no merge) but lacks details about side effects, partial updates, or error conditions. Since an output schema exists, return-value explanation is not required, but operational context is thin. This is adequate but not fully thorough.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description does not add new semantic meaning beyond the schema; it only reiterates the state parameter's purpose. According to the calibration, baseline 3 is appropriate when the schema covers parameters fully.

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 updates a GitHub pull request and explicitly includes closing or reopening as capabilities. It distinguishes itself from merging, which a sibling tool might handle, and the verb 'update' with the resource 'pull request' is specific and unambiguous.

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

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

The description provides a clear 'do not' for merging ('This does NOT merge') and explains how to close a PR without merging. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or conditions for reopening. The guidance is helpful but minimal.

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