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

Annotations already indicate the tool is not read-only and not destructive; the description adds the specific behavioral detail that it creates an inline comment on a line, but does not disclose side effects like notifications or permissions.

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

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

The description is a single, front-loaded sentence of 15 words with no unnecessary information, earning its place efficiently.

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

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

Despite having an output schema, the description fails to explain return values or behavior for invalid inputs. For a mutable tool with 6 required parameters and no parameter descriptions, additional context is needed for proper agent usage.

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

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

With 0% schema description coverage, the description provides no additional meaning for any of the 6 parameters. While parameter names like 'line', 'path', and 'comment_body' are somewhat self-explanatory, there is no guidance on format (e.g., markdown for comment_body) or constraints (e.g., valid line numbers).

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

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

The description clearly specifies the verb 'adds', the resource 'inline review comment', and the context 'to a specific line in a file within a PR', which distinguishes it from the sibling tool 'add_pr_comments' that likely adds general PR comments.

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 needing to comment on a specific line in a PR file, but does not explicitly state when to use this tool versus alternatives like 'add_pr_comments' for general comments, 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?

Annotations already indicate readOnlyHint=false, so the description's confirmation that this is a write operation adds little value. The description does not disclose any additional behavioral traits such as notification side effects, comment formatting constraints, or whether the operation is idempotent, which would be useful for an agent.

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

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

The description is a single, concise sentence with no fluff. However, it is too brief to fully serve the agent's needs, lacking essential context such as sibling differentiation. It is front-loaded but could be expanded slightly to include usage hints without becoming overly verbose.

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

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

Given the tool's simplicity and the presence of an output schema, the description is minimally adequate for a basic 'add comment' action. However, the lack of differentiation from the inline comment sibling and the omission of parameter semantics make it incomplete for an agent to reliably select and invoke the tool without further 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 0% schema description coverage, the description should compensate by explaining parameter meanings or constraints. It does not, though the parameter names ('repo_owner', 'repo_name', 'pr_number', 'comment') are reasonably self-explanatory. Missing details like required format for the comment string or numerical range for pr_number reduce clarity.

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 object ('Adds a comment to a specific pull request'), making the tool's purpose immediately understandable. However, it does not differentiate this tool from its sibling 'add_inline_pr_comment', which could cause confusion in selecting the correct tool for adding general vs inline comments.

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 the sibling 'add_inline_pr_comment' or any prerequisites (e.g., required permissions). This lack of context forces the agent to rely solely on the tool name to infer usage, increasing the risk of selecting the wrong tool.

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

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

The description goes beyond the idempotentHint annotation by explaining the concrete retry behavior: an already-attached item is returned and no duplicate card is created. This is useful behavioral context, and it does not contradict the annotations.

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

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

Two short sentences with no filler; the core action is front-loaded and the idempotency note is a valuable addition.

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 straightforward add-to-board operation with an output schema, the description covers the main behavior and the key edge case (duplicate items). It omits permission prerequisites and error handling, but these are not essential for selecting and invoking this tool correctly.

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

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

Schema description coverage is low (20%), and the description only indirectly clarifies parameters by identifying the item as an issue or pull request. However, the parameter names (project_owner, project_number, repo_owner, repo_name, issue_number) and the 'project board' wording make the mapping reasonably clear; the description adds minimal extra 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 a specific action—putting an issue or pull request onto a project board—and is not a tautology. It doesn't explicitly contrast itself with siblings like remove_from_project or set_project_field, so it lacks explicit sibling differentiation.

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

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

The intended use is implied: call this when an issue or PR needs to be added to a project board. It gives no explicit guidance about when not to use it or which sibling tool to choose instead.

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 details the UI card, button clicking, and the resulting 'I selected:' message format. It also mandates stopping after calling. It does not cover edge cases like option limits but is transparent for the main 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 front-loaded with purpose and is appropriately sized. It includes necessary usage details without excessive verbosity, though minor redundancy could be trimmed.

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 simple nature of the tool and lack of output schema or annotations, the description is complete. It covers input, behavior, user interaction, and the required post-call waiting instruction.

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 each parameter. The description adds minimal semantic value beyond what the schema provides, maintaining the 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 'Present the user with a set of options to choose from' and explains the interactive card with buttons. It distinguishes itself from sibling GitHub PR/issue tools by being a UI decision tool.

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

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

Explicitly says when to use: 'when you need the user to make a decision between discrete alternatives' and instructs to call it proactively. Includes critical instruction to stop and wait. Does not explicitly list when not to use, but context 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?

Annotations indicate readOnlyHint=false, so the description's write-operation semantics are consistent. However, the description adds no behavioral context beyond what annotations already convey—no mention of authentication needs, side effects, validation rules, or failure scenarios. The output schema exists but the description doesn't hint at what happens after creation.

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

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

The description is a single, concise sentence with no redundancy. However, it is so terse that it omits essential operational context, making it underwhelming rather than efficiently informative. It is concise but at the cost of usefulness.

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

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

With 6 parameters, 5 required, and no guidance about repositories, prerequisites, or alternative tools, the description is far from complete. The presence of an output schema helps but does not replace the need for context on when and how to invoke the tool correctly.

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

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

Schema description coverage is only 17% (milestone lacks a description, and the other five required parameters have none). The description does not compensate by explaining parameters like repo_owner, repo_name, title, body, or labels. While parameter names are mostly self-explanatory, the description adds zero semantic value over 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?

The description 'Creates a new issue.' clearly states the action (create) and object (issue), and is semantically distinct from sibling tools like update_issue and create_pr. However, it does not mention the repository context or that this is for GitHub issues, which limits full differentiation from similar creation 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?

There is no guidance on when to use this tool versus alternatives. The sibling list includes update_issue, create_pr, and create_milestone, but the description provides no criteria for choosing this tool over others, nor 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, which covers mutability and non-idempotence. The description adds a useful failure mode—reusing a title fails on a per-repository basis. No other behavioral traits like authorization or response details are disclosed, but the added constraint gives some context beyond annotations.

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

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

Two sentences with zero filler. The key constraint (title uniqueness) is stated directly and the description is appropriately sized for the tool's 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?

The output schema exists, so return values need no explanation. Required parameters and the default state are covered by the schema. The major gap is the ambiguous 'Opens' wording, the lack of usage guidance, and the sparse parameter-level detail in the description. The uniqueness note is helpful, but overall the definition is thin for a 6-parameter mutating 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 only 17%, so the description should compensate heavily. It only adds meaning for 'title' (uniqueness) and weakly hints at 'state' via 'Opens'. The parameters repo_owner, repo_name, description, and due_on receive no semantic explanation beyond the schema's basic type and default 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 names a resource (milestone) and an action ('Opens'), which is clear enough when combined with the tool name create_milestone. The uniqueness note on titles makes the creation intent clear, but 'Opens' could also be misread as changing the state of an existing milestone. It still stands out reasonably from siblings like update_milestone.

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. The description never mentions update_milestone, set_issue_milestone, or list_milestones, nor does it clarify that this is for creating a new milestone rather than modifying an existing one.

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

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

Annotations indicate this is not read-only, but the description adds no behavioral context beyond the purely functional. It does not mention side effects (e.g., triggering CI, notifications), required permissions, or potential failures (e.g., merge conflicts). With minimal annotation coverage, the description should carry more weight.

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 short (one sentence), which is concise but at the cost of omitting essential information. It does not front-load critical usage details, and every sentence should 'earn its place'—here, it barely does.

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 7 parameters (6 required) and no parameter documentation, the description is incomplete. While an output schema exists, the lack of parameter guidance and usage context means the agent cannot reliably invoke this tool. The complexity of creating a pull request demands more thorough description.

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

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

The input schema has 7 parameters with 0% description coverage, and the tool description does not explain any parameter meaning (e.g., what 'head' and 'base' refer to, or the role of 'draft'). This leaves the agent guessing about parameter semantics.

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

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

The description is concise and directly states the tool's function: creating a pull request. It uses a specific verb ('creates') and resource ('pull request'), clearly distinguishing it from sibling tools like 'merge_pr' or 'update_pr_description'.

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, such as when to create an issue instead of a PR, or prerequisites like branch existence. The presence of many sibling tools makes this lack of guidance a significant gap.

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

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

Annotations declare idempotentHint=false, but the description claims 'a retry after a half-finished release recovers' and that an existing tag's release is updated instead of rejected. That is an idempotency/retry-safety claim that contradicts the annotation. While the upsert detail is otherwise valuable, the direct conflict forces a score of 1.

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: the first front-loads the main action, the second adds a high-value retry/upsert behavior with a cross-reference. No fluf. 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?

Despite having an output schema and annotations, this is a 9-param mutation tool with zero schema descriptions. The overview is too terse to be complete: no parameter semantics, no routing vs update_release/create_tag, and a conflicting retry claim. Agents could easily call it incorrectly.

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

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

Schema description coverage is 0%; the description compensates for none of the 9 params. It never explains make_latest's enum, generate_release_notes behavior, draft/prerelease flags, or required body/release_name semantics, leaving an agent to guess at important inputs.

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

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

States a specific verb and resource ('Creates a new release') and then adds a crucial distinguishing nuance: an existing tag's release is updated rather than rejected. This separates it from sibling tools like get_release and update_release without needing to inspect their schemas.

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

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

The intended use is implied: call this to create a release, and a retry after a half-finished release should work. However, it never explicitly names alternatives or says when NOT to use it, e.g. when update_release or create_tag would be a better choice.

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

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

Annotations already indicate this is a mutating, non-idempotent operation. The description adds useful context by explaining the annotated vs. lightweight tag behavior. It does not disclose failure modes such as duplicate tag handling or permission requirements, but it is not misleading and provides some value beyond the annotations.

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

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

The description is two sentences long, front-loads the primary purpose, and every sentence adds useful detail. It has no filler and is easy to parse quickly.

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

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

The tool is relatively simple, annotations cover the mutating nature, and an output schema is present. The description explains the core behavioral nuance of annotated vs. lightweight tags. It could be more complete by mentioning what happens if a tag already exists or how this relates to sibling tag/release tools, but nothing essential prevents an agent from using 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 description coverage is only 20%, so the description partially compensates by explaining the 'message' parameter's role in determining tag type. Other parameters, like repo_owner, repo_name, and tag_name, are self-explanatory from their names, and the schema already documents the 'sha' parameter. Overall, the description adds some meaning but does not fully cover all parameter semantics.

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

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

The description uses a specific verb and resource: 'Creates a new tag.' It also adds meaningful distinction between annotated and lightweight tags, which gives the agent a clear idea of what the tool does beyond the name.

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

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

The description implies usage by stating it creates a tag, and it explains that a message yields an annotated tag while omitting it yields a lightweight ref. However, it does not explicitly discuss when to choose this over sibling tools like delete_tag, list_tags, or create_release, or mention any conditions to avoid using 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?

Beyond the destructiveHint annotation, the description discloses the important side effect: the tag is not automatically deleted and is only removed when delete_tag is true. It also explains the rationale about not moving commit history, which is exactly the kind of behavioral context annotations do not provide.

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

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

Two sentences with no padding. The primary action is front-loaded, and the second sentence adds valuable side-effect context without unnecessary detail.

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

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

For a destructive 4-parameter tool with annotations and an output schema, the description is nearly complete. It defines the action, the default behavior, and the optional tag-deletion flag. Minor omissions like permission requirements are not critical given the simple API shape.

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 only 25%, and the description partially compensates by clarifying the release/tag relationship and the meaning of delete_tag. The repo owner and repo name parameters are standard and self-explanatory, so their lack of detail is not a serious 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?

States a specific verb and resource: 'Deletes a release.' It also distinguishes itself from tag-only deletion by explaining that the tag survives unless the delete_tag flag is set, which separates it clearly from the sibling delete_tag 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 useful context about the release/tag relationship but does not explicitly say when to choose delete_release over alternatives like delete_tag or update_release. The intended use is implied rather than directly 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?

Beyond the destructiveHint annotation, the description discloses a non-obvious behavior: deletion is refused for release-referenced tags unless force is set, and it explains the consequence of removing such a tag. This is valuable, specific behavioral context that is not available from annotations alone.

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 no filler. The main action is front-loaded, and the second sentence earns its place by explaining the critical force behavior and its rationale.

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 delete operation, the description covers the action, the special case where force is required, and the reasoning behind that behavior. With the destructiveHint annotation and an output schema present, nothing essential is missing for an agent to select and invoke this tool correctly.

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

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

The description clarifies the force parameter by explaining when it is required, adding meaning beyond the schema. However, with only 25% schema description coverage, the three required parameters — repo_owner, repo_name, and tag_name — are not explicitly defined in the description. Their names are self-explanatory, but the description does not fully compensate for the low schema 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 opens with a specific verb and resource, "Deletes a tag," which directly states the tool's function. It also distinguishes this from release-oriented tools by explaining the tag-release relationship, making it easy to select over sibling tools like delete_release or create_tag.

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 clearly conveys the condition under which force is needed: deletion is refused when a release points at the tag. However, it does not explicitly mention when to prefer this tool over alternatives or when not to use it, so the usage guidance is mostly implied rather than 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 annotations already mark the tool as read-only and non-destructive, so the description adds value by explaining a behavioral trait: it reads from the issue itself rather than the search index, giving immediate visibility of recent writes. It also states the exact issue fields returned.

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 first two sentences are tight and front-load the core behavior and the distinguishing read-consistency point. The trailing 'See #358' is a minor extraneous reference that does not meaningfully help an agent decide or call the tool.

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

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

For a simple read tool with an output schema and strong annotations, the description covers the essential context: single-issue scope, returned fields, and immediate-write visibility. Its only notable gap is not naming the relevant alternative tool for broader searches.

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% parameter description coverage and the text only clarifies issue_number through 'by number.' The other parameter names are self-explanatory, but the description does little to compensate for the complete absence of schema-level parameter documentation.

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

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

The description starts with a concrete verb and object — 'Fetches a single issue by number' — and lists the returned fields: body, labels, assignees, and milestone. This clearly distinguishes it from sibling list/search tools like search_issues_prs or list_open_ssues_prs.

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

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

It provides a clear usage cue by contrasting direct reads with the search index: 'so it sees a write immediately.' It does not explicitly name the alternative or state when not to use it, but the contextual guidance is recognizable.

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 aligns with readOnlyHint annotation, but adds no extra behavioral context beyond what annotations already provide. No mention of rate limits, permissions, or branch specification.

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 redundant information. Efficiently conveys the core functionality.

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?

Adequate for a simple fetch tool with output schema present, but misses critical detail: which branch's latest commit? Agent might assume default branch, but this is not explicit.

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

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

Schema description coverage is 0%, and the description does not explain the purpose of repo_owner or repo_name parameters. The agent receives no additional 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 fetches the SHA of the latest commit, with a specific verb and resource. It distinguishes from sibling tools, none of which focus on this exact operation.

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

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

No guidance on when to use this tool vs. alternatives like get_pr_content or get_pr_diff. No context about prerequisites or conditions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description doesn't need to repeat that. The description adds no extra behavioral details (e.g., output includes title, body, status) beyond the annotation safety profile.

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

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

The description is a single sentence and front-loads the purpose, but it is too brief for a tool with 3 parameters and no schema descriptions. It could be expanded with parameter guidance 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?

With an output schema present, the description doesn't need to detail return values, but it fails to define what 'content/details' includes in relation to siblings. Combined with no parameter help, the completeness is poor.

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

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

Schema description coverage is 0%, yet the description offers no explanation of the three required parameters (repo_owner, repo_name, pr_number). The user receives no hints on what values to provide, which is a critical 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 verb 'fetches' and the resource 'content/details of a specific pull request'. It distinguishes from siblings like 'get_pr_diff' which fetches only diffs, though it doesn't explicitly differentiate from 'get_pr_linked_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 such as 'get_pr_diff' or 'get_pr_linked_issues'. No when-not-to-use or context for selection is given.

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

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

With readOnlyHint and destructiveHint already in annotations, the description adds valuable behavioral detail: the result is capped at max_bytes, and bytes_total always reflects the full patch so truncation is detectable. This goes beyond the annotation safety signals without contradicting them.

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

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

The first two sentences are concise and front-loaded with the core behavior and truncation caveat. However, 'See #314' is a cryptic reference that adds little for an AI agent, and the description could either elaborate or drop it.

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 output schema presumably documents return fields, and annotations cover safety, so the core fetch behavior is adequately captured. The main gaps are missing when-to-use guidance relative to closely related tool names and the opaque '#314' reference.

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 only 25% and the description adds little to parameter meaning: it only repeats that max_bytes caps the patch, while the schema already says that. repo_owner, repo_name, and pr_number are never explained, though their purpose is inferable from the tool name.

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 ('Fetches') and names the exact resource ('the diff/patch of a specific pull request'), then adds the max_bytes cap as a distinguishing behavior. This clearly separates it from sibling tools like get_pr_content and get_pr_status_checks.

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

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

No guidance is given about when to choose this tool over alternatives (e.g., get_pr_content) or when not to use it. The only contextual phrase is 'specific pull request', which does not establish selection 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?

Annotations already declare readOnlyHint true, and the description adds that it returns issues for auto-closing. However, it could detail whether all linked issues or only those with specific keywords are returned.

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 efficiently conveys the core purpose. No redundant information, every word earns its place.

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

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

Given an output schema exists, the description adequately covers what is returned. It could mention prerequisites like PR existence or linking keywords, but overall sufficient for a 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?

With 0% schema description coverage, the description does not explain parameters at all. The parameter names are self-explanatory, but no additional semantics are provided.

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 returns issues auto-closed on PR merge, with a specific verb and resource. It distinguishes from sibling tools like get_pr_content or get_pr_diff by targeting linked 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 on when to use this tool versus alternatives like list_open_issues_prs or get_pr_diff. The description only states what it does, not the context for 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by revealing that output includes single-select options and that these names align with set_project_field, but it does not describe output shape or any limitations. This is reasonable given the annotations.

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

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

A single sentence that front-loads the core action and resource, then adds the most important qualification: that the output is what set_project_field expects. There is no redundant or filler content.

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

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

The tool is simple, has an output schema, fully documented parameters, and read-only annotations. The description provides the missing relational context with set_project_field. Nothing an agent needs to invoke it correctly appears to be missing.

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

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

Schema description coverage is 100%, so both project_owner and project_number are already documented in the input schema. The description does not add significant parameter-level detail, but the schema carries that burden. This earns the 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 states a specific verb and resource: it lists a project's fields and the options for single-select fields. It also explicitly connects the output to what set_project_field expects, which clearly differentiates it from write-oriented sibling tools without needing to inspect schemas.

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

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

The description clearly implies when this tool is useful: before calling set_project_field, since it returns the exact field and option names that tool expects. It does not explicitly state exclusions or alternative read tools, but the reference to set_project_field provides strong contextual usage guidance.

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

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

Annotations mark the tool as read-only. The description goes far beyond by detailing pagination limits (50 per page, max pages), truncation detection, and the effect on the 'overall' field (downgraded to 'unknown' on partial results). This is rich behavioral context beyond what annotations provide.

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

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

The description is a single paragraph that starts with the main action, then efficiently explains pagination behavior and truncation handling. Every sentence adds necessary detail without fluff.

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

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

The description covers the algorithm well, but lacks parameter descriptions. With 3 simple required params and an output schema, the completeness is adequate but not thorough. The missing param documentation reduces the score.

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 3 parameters with 0% description coverage. The description does not describe repo_owner, repo_name, or pr_number individually. Although their meaning is somewhat inferable, for full clarity the description should provide at least brief explanations.

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 precisely states it returns CI check runs and commit status for a pull request's HEAD commit. This clearly differentiates it from sibling tools like get_pr_diff or create_pr, which have different purposes.

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 the tool (to get CI status), but lacks explicit guidance on when not to use it or alternatives. Among siblings, no other tool provides status checks, so differentiation is less critical, but still no 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the selection mechanism (by tag or latest published), which is useful beyond annotations. However, it does not disclose error behavior or any additional constraints, relying on the output schema to define returns. This is adequate but 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 a single, concise sentence that front-loads the core action and the key selection criteria. No wasted words; every part earns its place.

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

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

For a simple read operation with an output schema and safety annotations, the description covers the main decision (tag vs latest). It does not mention potential failure cases, but these are not critical given the simplicity. The required repository parameters are evident from the schema. Overall, it is complete enough for an agent to call 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 description coverage is only 33%, with only tag_name having a description. The tool description clarifies tag_name's optionality (omit for latest) but completely omits any context for repo_owner and repo_name, which are required. With low schema coverage, the description should compensate, but it does not address these parameters, leaving the agent to infer their meaning.

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

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

The description clearly states a specific action: fetching one release, either by tag or the latest published. It distinguishes from list_releases by specifying 'one release', implying it is not a listing operation. However, it does not explicitly name the alternative, so it falls short of the top score.

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?

Usage context is implied: use this tool when you need a single release by tag or the latest. There is no explicit mention of when not to use it or a comparison to sibling tools like list_releases. It provides enough context for basic selection but lacks explicit 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is covered. The description adds valuable non-obvious behavior: one REST call per repo checked, a recommendation to set max_repos conservatively, and the truncated flag meaning results may be incomplete. No contradiction with annotations.

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

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

The description is compact and every sentence earns its place: core purpose, date format, usage example, cost warning, and truncation caveat. No filler or repetition.

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

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

The presence of an output schema reduces the need to describe return values in prose. The description covers the key contextual concerns for this tool: cost per repo, truncation risk, and intended prompt type. The only notable omission is top_n semantics, but overall the tool is well contextualized.

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 must compensate. It clarifies 'since' formats and default behavior, and explains max_repos in terms of cost/truncation. However, top_n is never explained, and username is only implied, leaving a meaningful gap for a tool with zero parameter 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 names a specific verb ('Return'), resource ('repos owned by username'), and ranking criterion ('received the most new stars since a given date'). This clearly distinguishes the tool from the sibling tools, none of which are star-trend focused.

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 gives a concrete prompt example ('which repos gained the most stars in the last 30 days') and explains the time-window concept. It does not explicitly state when not to use the tool or name alternatives, so it stops short of a 5.

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

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

Discloses that repo_stars returns cumulative counts, not per-period deltas, which is critical behavioral information beyond annotations. No contradictions with readOnlyHint.

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

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

Two concise sentences with front-loaded purpose. Every sentence adds value: purpose and a behavioral caveat. 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 output schema exists, description need not detail return values. Covers filtering, date formats, and star delta caveat. Missing description for username and max_results, but overall adequate.

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 explains org, repo, since/until (including accepted date formats). However, username (required) and max_results are not described, leaving gaps.

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

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

Clearly states 'Get user activities' with optional filtering by org, repo, and date range. Verb and resource are specific. Distinguishes from siblings like get_repo_stars_since by focusing on activities broadly.

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 usage context: when to use filters and date formats. Lacks explicit guidance on when not to use this tool vs alternatives, though the repo_stars caveat helps avoid misuse.

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

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

No annotations exist, but the description details sandboxed execution, streaming via PrefabApp, variable injection via data, and layout behavior. It lacks mention of error handling or limits, but is otherwise transparent.

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

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

The description is long but well-structured with headings, code blocks, and bullet-style layout patterns. It could be more concise, but the structure aids readability.

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

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

Given the complexity (UI generation, reactive state, charts) and lack of output schema, the description covers essential usage patterns, layout constraints, and examples. It is sufficiently complete for an AI agent to use effectively.

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 only 0% description coverage, so the description must compensate. It thoroughly explains both params: code (Python building component tree) and data (injected variables), with multiple examples and syntax details.

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 'Execute Prefab Python code in a sandbox and render the result.' This is a specific verb+resource pair that distinguishes it from sibling tools which are all GitHub operations.

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?

Extensive guidance is provided: when to use (to create UI), how to structure code using PrefabApp, import components, use reactive bindings, and layout patterns. It also directs users to the `components` tool for component lookups.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds one useful behavioral detail beyond the annotations — that the result includes an issue count per milestone — but it says nothing about pagination behavior, default state filtering, or response characteristics. Not contradictory, just thin.

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 zero wasted words. The verb, resource, and key return-value detail ('count of issues') all appear in the first line. It is appropriately compact for a simple list operation, though it borders on too sparse to add much 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?

The tool is a simple read-only list operation with an output schema (return values documented elsewhere) and safety annotations, so the baseline burden is low. Still, the definition omits practical call context: no mention of the default state ('open'), pagination semantics, or which sibling to use for related milestone operations. 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?

Schema description coverage is only 40% (only 'state' and 'per_page' are documented), which falls below the 50% threshold, so the description must compensate for the undocumented params (page, repo_owner, repo_name). The description does not compensate at all — it merely implies 'a repository' without explaining any parameter semantics. The two documented params are the most meaningful, which prevents a score of 1, but the gap remains.

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 ('Lists') and a clear resource ('a repository's milestones'), so an agent can tell what the tool does and distinguish it from create_milestone, update_milestone, and set_issue_milestone by verb. It also adds a distinguishing detail (count of issues in each milestone). However, it never explicitly names sibling alternatives, so differentiation is implicit rather than stated.

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?

Usage context is only implied through the verb 'Lists', suggesting a read/view operation rather than creation or modification. There is no explicit guidance on when to prefer this tool over siblings like list_releases, list_tags, or list_repo_labels, and no exclusions or alternative routing.

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

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

Annotations already declare readOnlyHint=true, indicating a read operation. The description adds no additional behavioral context beyond the basic action, such as pagination behavior or rate limits, failing to leverage the opportunity to add value.

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 fluff. It could be more informative while remaining concise, but it is not overly verbose.

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

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

Given the tool's complexity (6 parameters, many siblings), the description is insufficient. It lacks information about filtering, pagination, and how it differs from detailed sibling tools like get_pr_content, making it hard for an agent to decide without additional 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 only 17% schema description coverage, the description must compensate by explaining parameters. However, it mentions none of the six parameters, leaving their meanings and defaults completely undocumented.

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 'Lists open pull requests or issues.' This clearly identifies the action (list) and the resource (open PRs/issues), distinguishing it from sibling tools that create, update, or merge PRs/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 usage guidance is provided. The description does not indicate when to use this tool over alternatives like get_pr_content or get_pr_diff, nor does it mention any prerequisites or filtering capabilities.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe-read nature is established. The description adds useful context by noting that inline comments carry file and line information. It does not disclose pagination behavior or the default kind=conversation behavior, but it does not contradict the annotations.

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

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

Two concise sentences, no fluff. The first sentence states the core operation immediately, and the second earns its place by giving meaningful behavioral context about inline comments. The structure is front-loaded and efficient.

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

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

The tool has six parameters, an output schema, and read-only annotations, so the description does not need to restate return types. However, it omits the meaningful default behavior of kind=conversation and gives no indication of pagination controls. This leaves an agent without enough context to know that listing 'comments' by default excludes inline comments, which is a real gap.

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

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

Schema description coverage is only 33%, covering kind and per_page, while repo_owner, repo_name, pr_number, and page lack schema descriptions. The tool description does not compensate: it never mentions required parameters or pagination, and it only indirectly supports the kind parameter by mentioning inline comments. With this low coverage, more parameter guidance was needed.

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

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

The description opens with a clear verb and resource: 'Lists the comments on a pull request.' It also adds a distinguishing detail about inline comments carrying file and line context, which helps differentiate this from comment-adding tools. However, it does not explicitly contrast with any sibling tool, so it stops just short of a 5.

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

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

The phrase 'so a second review can tell what it already said' implies a use case: checking existing PR commentary during review. But there is no explicit guidance on when to choose this over related tools like update_pr_comment, add_pr_comments, or get_pr_diff, and no exclusions are 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the tool returns field values for each card and supports status-oriented backlog reads. It does not discuss pagination or response size, but pagination is explained in the schema and output schema exists.

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 action and resource, then adds the motivating use case. There is no filler, repetition of schema fields, or redundant annotation language.

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

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

For a read-only list operation with an output schema and pagination parameters described in the schema, the definition provides the necessary understanding: board scope, field-value details, and status-based use. It could more explicitly describe the identifier semantics for project_owner and project_number, but those are reasonably inferable. Overall, an agent has enough context to select and call the tool correctly.

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

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

Schema description coverage is 50%, with after and per_page well documented but required project_owner and project_number lacking schema descriptions. The description ties the operation to a 'project board', helping an agent infer that these parameters identify the board, but it does not explain owner format or how to obtain the project number. The parameter names are mostly self-explanatory, so the description adds only modest value.

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 ('Lists') and a resource ('project board'), and clarifies that each card's field values are returned. The phrase 'backlog can be read by Status rather than one issue at a time' differentiates it from single-item tools and from board-mutation tools. This makes the tool's purpose unambiguous relative to siblings.

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

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

The description explicitly frames the tool for reading a backlog by Status in bulk, which is clear usage context. It implies the alternative of reading one issue at a time but does not name a specific sibling tool or state when not to use it. The guidance is clear but not fully explicit.

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

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

Annotations already mark this as read-only and non-destructive, and the description is consistent with that. It adds the useful ordering guarantee 'newest first', but does not disclose pagination behavior or other nuances; the annotation coverage lowers the burden.

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

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

The description is a single sentence with no filler. The verb and resource are front-loaded, and the ordering detail is efficiently appended.

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-only list endpoint with an output schema and self-explanatory parameter names, the description is mostly adequate. However, it lacks routing context relative to get_release and explicit pagination notes, leaving a few gaps for the agent to infer.

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 only 25%, with only per_page documented. The description implies repo_owner and repo_name identify the repository, but it does not explain page behavior or other parameter semantics, so it only partially compensates for the low schema 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 the verb 'Lists', the resource 'a repository's releases', and the ordering 'newest first', making it immediately clear this is the collection counterpart to get_release. It distinguishes from mutation tools like create_release/delete_release, though it does not explicitly name an alternative sibling.

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

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

No guidance is given for when to use this tool versus get_release, list_tags, or release-related mutations. There are no exclusions, prerequisites, or alternative-routing hints, so usage must be inferred entirely from the tool name and resource type.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no behavioral detail beyond what the annotations convey—nothing about pagination limits, ordering, or repository permissions. It is consistent with annotations (no contradiction), so a baseline 3 is appropriate.

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

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

A single, compact sentence with no wasted words, and the core action is front-loaded. It is concise, though the brevity is partly a consequence of under-specification rather than deliberate optimization.

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

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

This is a simple read-only list tool with an output schema present, which reduces the burden on the description. However, it omits any mention of pagination behavior or the meaning of the page parameter, and gives no usage context. Adequate for a minimal list tool, but with clear gaps.

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

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

Schema description coverage is only 25% (only per_page has a description); repo_owner, repo_name, and page are undocumented in the schema. With coverage below 50%, the description is expected to compensate, but it explains none of the parameters and adds no meaning beyond what the schema already provides.

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

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

The description uses a specific verb ('lists') and resource ('labels') scoped to 'a repository'. This clearly distinguishes it from sibling list tools like list_tags, list_releases, and list_pr_comments, which target different resources. It does not explicitly name siblings, but the resource 'labels' is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The description only states what it does, not when it should be selected over other list operations available among the many siblings.

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

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

Annotations already mark this as read-only and non-destructive. The description adds valuable behavioral detail beyond the annotations by explaining that the endpoint choice depends on the owner's account type and the failure modes of each endpoint (/orgs 404s on a person; /users hides org private repos). This helps an agent predict behavior before calling.

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

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

The description is compact and front-loaded with the core purpose, followed by the key behavioral nuance. The trailing 'See #354' is mildly unhelpful as a dangling reference, but the overall structure is efficient and easy to parse.

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 annotations cover the read-only safety profile, the description covers the main behavioral complexity: owner-type-dependent endpoint selection and the caller-omission case. It leaves pagination and sorting to the schema defaults, which is acceptable for a listing 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 50%, with owner and per_page already documented in the schema. The description reinforces the owner semantics by explaining the endpoint selection, which adds context, but it does not clarify page or sort meaning or compensate fully for the undocumented parameters.

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

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

The description states a specific verb ('Lists') and resource ('repositories') with clear scoping to a user, an organisation, or the caller. It immediately distinguishes this tool from sibling tools like list_releases, list_tags, and list_labels, which all target different resources.

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

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

The description gives clear context on when to use the tool and how owner type affects behavior, noting that omitting owner targets the caller and that /orgs vs /users depends on account type. It does not name explicit alternative tools, but there is no direct sibling that also lists repositories, so the context 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?

The annotations already declare readOnlyHint=true and destructiveHint=false, so no safety contradiction exists. The description adds that the tool returns the commit each tag points at, which is useful, but does not mention pagination or ordering 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 a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's core function.

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-only list operation with annotations covering safety and an output schema available, the description is nearly complete. It could be slightly stronger by acknowledging pagination or repository context, but nothing critical is missing.

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

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

Schema description coverage is only 25%, with only per_page described. The tool description does not explain repo_owner, repo_name, or page semantics, so it fails to compensate for the low schema 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 specific verb and resource: it lists a repository's tags and the commit each points at. This clearly distinguishes it from sibling tools like list_releases or create_tag/delete_tag.

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 this tool—when you need repository tags and their target commits—but it does not explicitly contrast it with alternatives like list_releases or explain 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?

The description only states 'merges' without disclosing behavioral traits such as side effects (e.g., closing the PR, updating branch), failure conditions (merge conflicts), or required permissions. Annotations provide minimal safety info (readOnlyHint false, destructiveHint false), so description should compensate but does not.

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, but it sacrifices critical information for brevity. It is front-loaded but does not earn its place as it omits needed detail. A slightly longer description would improve utility 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 tool's complexity (6 params, output schema), the description is severely incomplete. It does not mention the merge process, return value, prerequisites, or limitations. The presence of an output schema is not leveraged in the description.

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

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

The description adds no meaning to the 6 input parameters. With 0% schema description coverage, the description should explain parameters like commit_title, commit_message, and merge_method, but it fails to do so. Parameter names are self-explanatory, but the description does not clarify usage or required vs. optional fields.

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

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

The description 'Merges a specific pull request' clearly states the verb and resource, and is distinct from sibling tools (no other merge tool). However, it lacks specificity about the merge scope (e.g., into base branch) and does not differentiate from other PR action tools beyond the action itself.

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 vs. alternatives. Does not mention prerequisites (e.g., write access, mergeability) or scenarios where it should be avoided. Sibling tools like update_pr_branch could be confused without 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?

The annotations already indicate destructiveness, but the description adds important context: the issue or PR stays open and only the card's field values are lost. This helps the agent understand the real scope of the destructive action beyond the bare destructiveHint flag.

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 tight sentences. The first states the action, and the second adds the crucial side-effect clarification. There is no redundant or filler content.

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

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

For a destructive tool with five required parameters and an output schema, the description provides the core behavioral context needed: what is removed and what is preserved. It does not elaborate on parameter meanings or usage scenarios, but the clarity of the action and effect makes the definition reasonably 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 0%, and the description does not explain any of the five required parameters. While the parameter names are fairly self-explanatory, the description's mention of 'pull request' is not clearly mapped to the issue_number parameter, leaving some ambiguity for agents selecting parameters.

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

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

The description uses a specific verb and resource: 'Takes an issue or pull request off a project board.' It also clarifies the scope by stating the issue itself is untouched, which distinguishes this from issue deletion and reinforces the tool's specific role relative to siblings like add_to_project.

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 the tool: whenever an item should be removed from a project board. However, it does not explicitly state when to prefer this over alternatives such as add_to_project or set_project_field, and it gives no 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?

Annotations already indicate this is a mutating, non-idempotent, non-destructive operation. The description adds the behavioral nuance that it attaches to an existing thread rather than creating a new one, which is useful but not extensive. It does not mention response behavior or side effects beyond the reply itself.

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. Every word contributes to explaining the tool's purpose and its key distinction from starting a new thread.

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 relatively simple write operation combined with annotations and an output schema, but it leaves usage guidance thin and relies on self-explanatory parameter names. For a 5-parameter required call, more context about when to reply and how reply threading works would improve completeness.

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

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

Schema description coverage is only 20%, so the description should compensate for undocumented parameters. It does not: body, pr_number, repo_name, and repo_owner receive no additional explanation. The comment_id parameter already has a schema description, and the tool description mostly reinforces that existing meaning.

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

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

The description uses a clear verb ('Replies') and a specific resource ('existing review thread'), and explicitly distinguishes this tool from starting a new thread. This is enough to separate it from sibling comment-adding tools without opening their schemas.

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

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

The phrase 'rather than starting a new one' provides clear usage context: use this tool when replying to an existing review thread, not when creating a new comment thread. It does not name a specific sibling alternative, but the exclusion is explicit 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?

Annotations already mark the tool as read-only, and the description adds meaningful behavioral detail: closed and merged items are reachable, and any qualifier GitHub search accepts works. This goes beyond the structured safety hints.

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

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

Two sentences with no filler: the first states the core function, the second provides the crucial differentiating detail. Everything included earns its place.

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

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

For a read-only search tool with a full input schema, an output schema, and helpful annotations, the description covers purpose, usage distinction, and behavioral scope. No critical information is missing.

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

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

The schema documents query and per_page well, and the description reinforces that the query is caller-defined and accepts arbitrary GitHub qualifiers, adding useful meaning beyond the example. The page parameter is straightforward and its default is 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: 'Searches issues and pull requests by text and qualifiers.' It also explicitly contrasts itself with list_open_issues_prs, making the distinction from a key sibling clear.

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 names the alternative tool and gives the deciding factor: unlike list_open_issues_prs, this tool uses the caller's query, so closed/merged items and arbitrary GitHub qualifiers are supported. This tells an agent exactly when to choose this tool.

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

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

With no annotations, the description explains query matching (OR-matched), automatic detail modes based on result count, and the detail parameter override. It does not mention read-only nature explicitly but implies it. The behavior is well-covered.

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 usage, followed by parameter details. It is clear and well-structured, though the parameter descriptions are somewhat repetitive of the schema. Still, no unnecessary 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 complexity (4 parameters, output schema provided), the description covers purpose, usage context, parameter behavior, and output modes thoroughly. The output schema exists, so return format details are not needed. The description is complete for an API search 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 75%, and the description adds meaningful context for query, detail, and limit beyond the schema. The `components` parameter lacks description in both schema and description, but the description compensates for the other three with usage details like OR-matching and automatic mode.

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

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

The description clearly states it searches the Prefab component library to look up API details, distinguishing it from sibling tools which are unrelated (GitHub operations). The verb 'search' and resource 'component library' are specific and precise.

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

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

It explicitly advises using this tool before writing component code to find argument names and values, and contrasts it with a separate skill for patterns and layout. However, it does not name the alternative tool or explicitly state when not to use it.

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

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

Annotations already declare readOnlyHint=true, so the description's mention of using GraphQL API adds minimal extra context. No further behavioral details (e.g., pagination, rate limits) are provided.

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

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

A single, direct sentence with no extraneous information. Every word is necessary and the description is well 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 the tool is simple (1 param, output schema exists, annotations provided), the description is minimally adequate but does not explain what the search returns or how it compares to similar tools. The output schema likely fills some gaps, but the description could be more informative.

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 parameter 'username' has 0% schema description coverage, and the description only says 'by username' without adding format, constraints, or examples. This fails to compensate 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 the verb 'Search', the resource 'GitHub user', and the method 'by username using GraphQL API'. This distinguishes it from sibling tools like 'get_user_activities' which may have different 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?

No guidance on when to use this tool versus alternatives like 'get_user_activities' or other search tools. The description does not mention prerequisites, limitations, 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?

Annotations already indicate a non-read-only, idempotent, non-destructive mutation. The description adds valuable behavioral context by explaining why clearing a milestone requires null and why update_issue cannot handle that case. This is useful beyond what the annotations convey.

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

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

Two focused sentences: the first states the core action, the second explains the rationale for the tool's existence. 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 mutating tool with an output schema and clear annotations, the description fully covers purpose, the clearing edge case, and the reason to prefer this tool over update_issue. Required repo and issue identifiers are self-explanatory and visible in the 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 only 25%, with only the milestone parameter documented there. The description clarifies that milestone can be set or cleared, but it does not explain repo_owner, repo_name, or issue_number beyond their names, and the schema already documents the null-to-clear behavior for milestone.

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

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

States a concrete verb-resource pair ('Files an issue under a milestone') and covers the inverse operation ('or takes it off one'). Explicitly distinguishes itself from update_issue by explaining why a separate tool is needed, so an agent can tell it apart from sibling tools.

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

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

Names update_issue as the alternative and explains the null-dropping behavior that makes set_issue_milestone necessary for clearing a milestone. This gives clear, concrete guidance on when to use this tool instead of a closely related sibling.

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

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

Annotations already communicate mutation and idempotency; the description adds useful implementation context about GraphQL and the REST limitation. This goes beyond annotations without contradicting them.

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

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

Two concise sentences; the core action is front-loaded and the second sentence adds a valuable implementation note. No fluff.

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?

Simple tool with only four parameters, an output schema, and annotations covering side-effect profile. The description explains purpose, behavior, and the API reason, so nothing essential is missing 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?

Schema description coverage is only 25%, and the description does not add explicit parameter detail. However, repo_owner, repo_name, and pr_number are self-explanatory GitHub identifiers, and draft is already described in the schema. The description reinforces draft's role but adds little new meaning.

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

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

Description states a specific action — 'Moves a pull request between draft and ready for review' — with a clear resource and direction. This separates it from siblings like merge_pr or create_pr, and from general update_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?

Provides clear context for when this tool is needed: toggling draft status after creation, and explains why GraphQL is used because REST only supports draft at creation. It does not explicitly list sibling alternatives or exclusion conditions, but the context is reasonably 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?

The annotations already signal readOnly=false, idempotent=true, destructive=false. The description adds meaningful behavioral detail: the tool will automatically add the issue to the board if it isn't there yet, and it operates on human-readable names rather than node IDs. This is genuinely useful beyond what annotations provide, though auth/rate-limit details are not covered.

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

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

Two short sentences, front-loaded with the main action and followed by an important side-effect note. Every sentence contributes necessary information and there is no redundancy or filler.

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

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

For a 7-parameter mutation tool with an output schema and annotations, the description covers the key non-obvious behavior: automatic board addition and name-based field/option selection. It doesn't need to explain return values because an output schema exists. It could mention validation or failure cases, but the core calling context is 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 only 29%, with most parameters (repo_owner, repo_name, issue_number, project_owner, project_number) having no description. The tool description only partially compensates by explaining that field and option are names rather than IDs, but it doesn't clarify the five uncovered identifier parameters. Since the schema is mostly bare, the description should have taken on more of the semantic burden.

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 'Sets' and identifies the exact resource: a single-select field on an issue's card. It also distinguishes the operation from simple board-add or ID-based APIs by saying it uses field and option names rather than node IDs. This makes the tool's purpose unmistakable among siblings like add_to_project and set_issue_milestone.

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

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

The description gives clear context: use this when you need to set a single-select field on an issue card, providing the field and option by name. It also clarifies the when-to-use case for issues not yet on the board by stating they are added first. It doesn't explicitly name alternatives, but the use case is sufficiently clear to route an agent correctly.

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

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

Annotations indicate idempotentHint=true and readOnlyHint=false. The description does not contradict annotations but adds minimal behavioral context (e.g., no mention of overwriting behavior or auth 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?

Single sentence, no wasted words. However, it may be too terse for a tool with four parameters and no parameter descriptions.

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 mutation tool with four required parameters and no output schema details, the description is incomplete. It does not explain whether assignees are replaced or appended, nor does it specify scope (works for both issues and PRs directly).

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

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

Schema description coverage is 0%, and the description provides no parameter-specific meaning beyond 'assignees for an issue/PR.' The four required parameters are not explained, leaving the agent to guess their purpose.

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 assignees for issues or pull requests, using a specific verb and resource. It distinguishes itself from sibling tools like update_issue or create_issue.

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 (e.g., update_issue). No mention of prerequisites or context, leaving the agent to infer usage.

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

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

The annotations already mark this as non-read-only, idempotent, and non-destructive. The description adds meaningful behavioral context: only supplied fields are sent and the rest keep their current values, which is essential for predicting edit behavior. This goes beyond what the annotations alone convey, though it does not describe every possible side effect.

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 concise sentences with no filler. The core purpose is front-loaded, and the partial-update behavior is stated immediately after, making it easy to parse. 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 that an output schema exists, annotations cover safety traits, and the input schema documents each editable field, this description is complete for the tool's complexity. The partial-update semantics are the main behavioral nuance an agent needs to know, and they are explicitly 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?

The input schema already documents the optional fields body, state, title, and labels with explicit 'omit to leave' descriptions. The description reinforces this with a single general rule that applies to all parameters, which is valuable. Required parameters are self-explanatory, and the 57% schema coverage is partially offset by the clear parameter names and the partial-update statement.

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

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

The description states a specific verb and resource: 'Updates an existing issue.' This clearly differentiates from create_issue and update_pr siblings by identifying both the action and the object. The second sentence adds the key partial-update scope, making the tool's purpose precise.

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 clearly establishes that this tool is for modifying an existing issue, which implies it should not be used to create new issues. It does not explicitly name alternatives such as create_issue, but the context is clear enough for an agent to select it correctly. No exclusions or warning conditions are described, so it falls short of a 5.

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

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

The description discloses a non-obvious behavior beyond the annotations: 'Only the fields supplied are sent, so closing one leaves its title and due date alone.' This PATCH-like semantics is valuable even though idempotentHint and destructiveHint already cover safety. No contradiction exists between the description and annotations.

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

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

Two sentences, no filler, front-loaded with the action and then the most important behavioral nuance. The example 'closing one leaves its title and due date alone' earns its place by making the partial-update semantics concrete.

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

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

Given the output schema exists and the input schema documents the required and optional parameters, the description is mostly complete. It covers the core update semantics and partial-field behavior; only an explicit note about requiring an existing milestone could add a bit more, but 'in place' already implies that.

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 71% schema coverage, the schema handles most parameter descriptions, but the description adds the key generalization that omitted fields are not modified. This clarifies optional parameters like state and due_on, where the schema does not explicitly say 'omit to leave alone.'

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 'Changes a milestone in place' states a specific verb and resource, clearly distinguishing this update tool from create_milestone and from set_issue_milestone, which assigns an issue to a milestone. The phrase 'in place' reinforces that it modifies an existing milestone rather than creating a new one.

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

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

The description provides clear context: use this tool to modify an existing milestone, and the partial-update note explains how to preserve unspecified fields. It does not explicitly name alternatives or say when not to use it, but the intended use is not ambiguous.

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

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

Annotations already indicate this is a mutating, non-destructive, idempotent operation. The description adds valuable behavioral context by disclosing the PATCH-like semantics: only supplied fields change, and omitted fields keep their current values. It does not detail side effects such as closing a PR via the state field, but that information is present in 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 two sentences with no filler. It front-loads the core action and then immediately gives the most important behavioral nuance, followed by a concrete example. 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 output schema exists and the annotations cover safety and idempotency, the description is mostly complete for effective invocation. It lacks guidance on sibling specializations, which could matter in this large toolset, but the essential call semantics are clear.

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

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

The schema already provides useful descriptions for base, body, state, and title. The description adds the critical partial-update interpretation, clarifying that parameters are optional and that omitting them is not a reset. This meaningfully compensates for the partial schema description coverage and helps an agent call the tool correctly.

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

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

The description states a specific verb and resource: 'Updates an existing pull request.' It is clear and unambiguous. However, it does not distinguish this general tool from sibling update tools like update_pr_branch, update_pr_description, or update_assignees.

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

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

The description implies the tool is appropriate for partial updates by explaining that only supplied fields are sent and other fields retain their values. It does not explicitly state when to prefer this tool over specialized siblings, nor does it give exclusions like 'use update_pr_branch for base retargeting.'

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

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

The description adds context about upstream changes, which is beyond the annotations (idempotentHint=true, readOnlyHint=false). However, it does not explain what happens during the update (e.g., merge vs rebase) or potential side effects like conflicts.

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 efficient sentence, but it could include more useful information without becoming overly verbose. It is missing critical details, making it less effective.

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 4 parameters and an output schema, the description is too brief. It omits details about the optional parameter, output behavior, and when to use the tool. The existence of an output schema is not referenced.

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

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

Schema description coverage is 0%, and the description does not explain any parameters (e.g., the purpose of expected_head_sha). The schema provides types and required flags but no semantic meaning.

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

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

The description clearly states the action ('updates'), the resource ('pull request branch'), and what it does ('with latest upstream changes'). This is specific and distinguishes it from siblings like merge_pr or create_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?

No guidance is given on when to use this tool versus alternatives like merge_pr or update_reviews. It does not mention prerequisites, scenarios, 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?

Annotations already provide mutation and idempotency hints, but the description adds important non-obvious behavior: conversation and review comments have separate id spaces and the kind must match the source of the id. This goes beyond the structured annotations and helps prevent a real failure mode.

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

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

Two sentences with no filler. The core action is front-loaded, and the critical id-space caveat follows immediately. 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 description covers the key mutation and the id-space/kind constraint, and an output schema exists so return values need not be described. However, it lacks explicit guidance for choosing between sibling comment tools and does not explicitly map 'review comments' to the 'inline' enum value, which a less experienced agent could misinterpret.

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 low (only comment_id is documented), so the description carries significant weight. It explains the relationship between kind and comment_id, which is the most ambiguous part of the schema. repo_owner, repo_name, and body are not elaborated, but their names are largely self-explanatory.

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 ('Rewrites a comment already posted') with a specific verb and resource. It distinguishes this from adding or replying to comments through the 'already posted' qualifier, though it does not explicitly name sibling tools or contrast them.

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

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

The phrase 'already posted' implies this tool is for existing comments rather than new ones, and the kind/comment-id guidance is useful when invoking. However, it never explicitly says when to use this tool versus add_pr_comments, add_inline_pr_comment, or reply_to_review_comment, so alternative selection is left to inference.

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

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

Annotations provide readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds 'Updates' which is consistent, but does not disclose additional behavioral traits beyond what annotations already indicate.

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

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

The description is a single concise sentence that front-loads the core purpose with 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?

Given the tool has five parameters and many sibling tools, the description lacks contextual completeness; it does not mention prerequisites or clarify partial update behavior.

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 partially compensates by mentioning 'title' and 'description' corresponding to new_title and new_description, but does not explain the repo_owner, repo_name, and pr_number parameters.

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

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

The description clearly states it updates the title and description of a specific pull request, using a specific verb and resource, and distinguishes from sibling tools like merge_pr or add_pr_comments.

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