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

With no annotations provided, the description carries the full burden of disclosing behavior. It states the main effect (no longer considered for submission) and the mutation nature, plus a warning to confirm with the user. It stops short of mentioning prerequisites like permissions or whether the operation is reversible, but covers the essential behavioral traits.

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

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

The description is three concise sentences, front-loaded with the primary purpose, then the effect, and finally usage caution. Every sentence earns its place with no redundant information.

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

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

The tool is a simple mutation with two parameters and no output schema, so the description reasonably covers purpose and effect. However, it omits potential prerequisites such as required permissions (e.g., being change owner) or whether the operation is reversible via restore_change. These gaps could leave an agent uncertain about invoking it correctly in all contexts.

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?

Both parameters are fully described in the schema (change_id and message), so schema coverage is 100%. The description adds 'Provide a reason message' which reinforces the message parameter but does not add new semantic meaning. There is a subtle ambiguity: the schema marks message as optional, while the description implies it should be provided, but this does not rise to a contradiction.

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 ('Abandon a Gerrit change') with a specific verb and resource, distinguishing it from siblings like restore_change and submit_change. The effect is explicitly described: 'The change will no longer be considered for submission.'

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 usage context by labeling this as a mutation and emphasizing user confirmation before calling. While it does not explicitly contrast with alternatives, the caution about intentional use and confirmation is a clear guideline for when to call 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 carries the full burden. It explicitly warns that it is a mutation and notes that the reviewer will be notified, which are important behavioral traits. It doesn't discuss reversibility or permissions, but enough is disclosed for basic safe use.

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. The first sentence defines the purpose, the second adds input types and side effects. Highly concise and well-structured.

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

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

For a simple mutation with two parameters and no output schema, the description covers purpose, parameter forms, mutation flag, and notification side effect. Missing return-value details, but not critical for this operation.

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

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

Schema coverage is 100% for two parameters, so baseline is 3. The description reiterates the reviewer input forms but adds minimal new 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 action ('Add a reviewer to a Gerrit change') with a specific verb and resource. It distinguishes from siblings like list_reviewers and post_review by the nature of the operation.

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

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

No explicit when-to-use or alternative references are given. The description implies usage for adding a reviewer, but lacks guidance on when not to use or how it differs from similar mutation tools.

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

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

No annotations are provided, so the description carries the full burden. It states the action and the special 'self' behavior but does not disclose the return format, potential errors, or any auth requirements. For a simple read operation, this is marginal but acceptable.

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

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

The description is a single, concise sentence that immediately states the tool's purpose and the special 'self' usage. 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's simplicity (one parameter, no output schema), the description is complete enough to understand its function and basic usage. It could mention when to use it instead of query_accounts, but the context from sibling tools helps fill that gap.

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

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

Schema description coverage is 100%, and the account_id parameter is fully described in the schema. The tool description does not add additional parameter semantics beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb 'Get' and clearly identifies the resource as 'a specific Gerrit account', distinguishing it from sibling tools like query_accounts which search for accounts. The addition of the 'self' keyword further clarifies the tool's scope.

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

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

The description provides clear usage guidance by explaining the special 'self' value for retrieving the current user's account. However, it does not explicitly contrast with query_accounts, though the sibling name and the phrase 'specific account' imply the differentiation.

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

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

No annotations are provided, so the description carries the burden of explaining behavior. It discloses that the tool returns full metadata and lists the categories included, which is useful. However, it does not mention whether any write operations occur (though 'Get' implies read-only), potential authentication requirements, rate limits, or error behaviors. The description provides moderate transparency but could be richer.

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 is concise and front-loaded with the core purpose. Every word contributes meaning: the verb, resource, specificity, and the list of returned metadata. 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?

With no output schema, the description must explain the return value. It lists key metadata categories (owner, labels, messages, revisions, reviewers), giving a good sense of what to expect. However, it doesn't mention whether the response is paginated, how options modify the response, or error handling. Given the moderate complexity of the tool, the description is mostly complete but has some gaps.

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

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

The input schema covers 100% of the parameters with clear descriptions for both change_id and options. The description adds little beyond the schema; it mentions 'full metadata' which relates to the options parameter but doesn't explain how options affect the response. Since the schema already documents the parameters well, a baseline of 3 is appropriate.

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

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

The description clearly identifies the tool's function: retrieving detailed information about a specific Gerrit change. It specifies the resource ('Gerrit change'), the verb ('Get'), and the scope ('specific'), which distinguishes it from sibling tools like query_changes that search for changes. The mention of specific metadata (owner, labels, messages, revisions, reviewers) further clarifies the tool's intent.

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

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

The description implies the tool is for fetching full details of a single change, but it does not explicitly state when to use it over alternatives or mention exclusions. For example, it doesn't say 'use this instead of query_changes when you already have a change_id' or 'not for listing multiple changes.' The usage context is present but not 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?

With no annotations, the description carries the burden. It discloses the output contents (subject, body, author, committer, parent commits), which is helpful. But it does not mention potential error conditions, authentication needs, or whether the operation is read-only (though 'get' implies it). This is adequate but lacks depth.

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, front-loaded with the core action and then enriched with output details. Every word earns its place with no redundancy.

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

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

For a simple read tool with full schema coverage, the description is largely complete: it states purpose and output contents. It does not provide guidance on alternatives or edge cases, but given the tool's simplicity, this is a minor 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 100%, so the schema already documents both parameters (change_id and revision_id). The description adds no extra parameter meaning, so the baseline of 3 applies.

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

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

The description clearly states the tool 'Get the full commit message for a revision of a Gerrit change', which is a specific verb+resource combination. It also lists the contents (subject, body, author, committer, parent commits), distinguishing it from sibling tools like get_change_details or list_change_files.

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 usage context is implied: if you need a full commit message, this is the tool. However, there is no explicit guidance on when to use this instead of siblings like get_change_details, no exclusions, and no alternative tool references.

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

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

With no annotations provided, the description carries the full burden. It discloses the return format (unified diff with added/removed/modified lines and context), which is useful. However, it omits edge-case behaviors like handling of binary files, invalid file paths, or revision fallback details, leaving some transparency gaps.

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, each earning its place: the first states purpose, the second describes return content. No fluff, front-loaded, and appropriately sized.

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 tool with fully documented parameters and no output schema, the description adequately explains both functionality and return format. It is complete enough for an agent to select and invoke the tool, though it could optionally mention the revision_id default.

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

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

Schema description coverage is 100%, so all three parameters are already well-documented. The description adds no extra meaning beyond the schema, meeting the baseline for high coverage but not exceeding it.

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

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

The description clearly states 'Get the diff of a specific file in a Gerrit change' with a specific verb and resource, distinguishing it from siblings like get_change_details (whole change) and list_change_files (file listing). It also specifies the return type (unified diff) which reinforces purpose.

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

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

The context is clear for when to use this tool (when you need a specific file's diff), but it doesn't explicitly mention alternatives or exclusion criteria. No sibling tool is named as an alternative, so guidance is implied rather than 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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. While the verb 'Get' suggests a read-only operation, the description does not explicitly state that it is non-destructive, whether special permissions are required, or any other side-effect information. It only lists the content returned, leaving the safety profile ambiguous.

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

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

The description is two sentences, front-loaded with the primary purpose and then listing the returned content categories. Every word contributes to understanding the tool, with no redundancy or filler.

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

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

Given the lack of parameters, annotations, and output schema, the description provides a reasonably complete picture by enumerating the types of information returned. It could improve by explicitly addressing read-only guarantees or auth requirements, but the simplicity of the tool reduces the need for additional detail.

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

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

The tool has zero parameters, and the schema is empty, so there is nothing to add beyond the baseline. The description appropriately does not mention any parameters, and the context signals confirm 100% schema coverage by default.

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

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

The description states a clear verb+resource: 'Get Gerrit server configuration info.' It further specifies the scope by enumerating capabilities, authentication methods, change settings, download schemes, and plugin info, which differentiates it from sibling tools like get_server_version that focus solely on version.

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 server configuration details are needed, but it does not explicitly mention alternatives or when not to use it. For example, it could have noted that get_server_version is the right tool for just the version. Thus, it provides only implied guidance, not 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?

No annotations are provided, but the description inherently indicates a read-only operation by using 'Get' and 'Returns.' It does not go into authentication, error handling, or format details, but for a simple parameterless getter, this is adequate.

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

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

The description is very short, but the second sentence largely repeats the first ('Get the version' vs 'Returns the version'). While compact, it could be a single sentence without loss.

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 the tool is a simple getter with no parameters, no output schema, and no nested objects, the description covers everything needed: what it does and what it returns. There is no missing behavior or context.

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

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

The tool has zero parameters, and the schema is empty, so parameter documentation is not needed. The description does not add parameter information, but the baseline for zero parameters is 4.

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

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

The description clearly states a specific verb ('Get') and resource ('Gerrit server version string'), and it explains the return value. It is distinguishable from siblings like get_server_info by focusing solely on the version string.

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

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

The description implies usage (when you need the server version) but does not explicitly compare to alternatives such as get_server_info. No when-not-to-use conditions are given, so guidance is implicit rather than 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?

No annotations are provided, so the description carries the full burden. It discloses return content (inline vs file-level, unresolved status, reply chains), implying a read-only operation. However, it doesn't mention pagination or authentication requirements, leaving some transparency gaps.

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

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

Two sentences, front-loaded with the core action. No fluff; information about return types and status is efficiently included.

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 one parameter and no output schema, the description sufficiently outlines what is returned (inline comments with location, file-level comments, unresolved status, reply chains). It lacks details like pagination, but for a list tool of this simplicity, it is near-complete.

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

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

Schema coverage is 100% with `change_id` described. The description adds no new parameter info, but the schema already fully explains the parameter, so baseline 3 is appropriate.

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

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

Clearly states 'List all comments on a Gerrit change', identifying the verb (list), resource (comments), and scope (on a change). It distinguishes from write-oriented siblings like post_review_comment and get_change_details by focusing specifically on listing comments with details like inline/file-level and status.

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 that this is for retrieving comments, but does not explicitly state when to use over alternatives or mention exclusions. No comparison to siblings like get_change_details, so it's implied rather than 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?

No annotations are provided, so the description must carry the full burden. It goes beyond a simple label by defining status codes (A, D, R, W, M) and stating that size and line counts are returned, giving the agent concrete expectations for the response. However, it does not disclose authentication requirements, error behavior, or pagination.

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 effectively communicates the tool's purpose, output format, and status code legend without superfluous words. It is front-loaded with the verb and resource.

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 listing tool with two well-described parameters and no output schema, the description sufficiently covers the return format and status meanings. The schema handles parameter information, and the description explains what the tool returns, making it complete for the given complexity.

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

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

Both parameters (change_id and revision_id) have detailed schema descriptions, so schema coverage is 100%. The tool description does not add any additional meaning beyond the schema, and the baseline for full schema coverage is 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 uses the specific verb 'List' and resource 'files modified in a Gerrit change,' and details the return fields (file paths with status, size, line counts). This clearly distinguishes it from siblings like get_file_diff and list_change_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 for obtaining an overview of changed files in a Gerrit change, but it does not explicitly state when to use this tool over alternatives or mention exclusions. The purpose is clear, but guidance is only inferred, not 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?

No annotations are provided, so the description carries the burden. It adds useful context like 'accessible to the current user' and optional descriptions, but does not disclose default limit, pagination, ordering, or return format. For a read-only list, this is adequate but not rich.

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

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

The description is two concise sentences, front-loaded with the primary action and resource. Every word earns its place, with no redundancy.

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

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

The tool is simple and schema covers all parameters, but there is no output schema and no mention of default limit or pagination behavior. The description is adequate for a basic list tool but leaves some expected context uncovered.

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

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

Schema coverage is 100%, so the baseline is 3. The description repeats the prefix and description parameters but omits the limit parameter. It adds little 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 clearly states the verb 'List', the resource 'Gerrit projects', and the scope 'accessible to the current user'. It distinguishes itself from sibling tools by focusing on project listing, which no other sibling does.

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 use this tool versus alternatives. The description mentions filtering by prefix and including descriptions, but it does not provide context, prerequisites, or exclusions relative to sibling tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explains the return content (reviewers, CC'd users, removed reviewers, approval status) but does not explicitly state that the operation is read-only, nor any error handling or authentication requirements. This is adequate for a simple list operation but leaves some gaps.

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 short sentences, front-loaded with the primary action, and includes only the essential output details. 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 low complexity (one parameter, no output schema), the description adequately explains what the tool returns. It does not detail the exact return structure, but the listing of reviewer categories is sufficient for an agent to understand the tool's purpose and expected result.

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

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

Schema description coverage is 100% for the single parameter change_id, which already documents the accepted formats. The tool description adds no further parameter meaning, so it does not exceed the schema baseline.

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

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

The description clearly states the tool's action ('List all reviewers of a Gerrit change') and the specific resource (reviewers). It also distinguishes the output categories (reviewers, CC'd users, removed reviewers) which are unique among sibling tools like add_reviewer or list_change_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 gives clear context for when to use the tool: whenever you need to see the reviewers of a change. It does not explicitly compare with alternatives, but the purpose is unambiguous and no exclusions are needed.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool is a mutation and advises intentional use, which is valuable. However, it does not mention side effects like overwriting existing labels, the permanence of the action, or permission requirements, leaving gaps in what an agent should expect.

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

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

The description is three sentences, with the primary action front-loaded and no redundant words. Each sentence adds meaning: what it does, concrete use cases, and a caution. It is efficiently 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 description covers the core purpose and parameter usage, but given there is no output schema, it does not mention what the response contains or how to interpret success/failure. It also omits any prerequisites beyond the required change_id, which is present in the schema. Overall, it is adequate for selection but not fully complete for a tool with 7 parameters and no output schema.

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

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

Schema coverage is 100%, so a baseline of 3 is appropriate. The description adds value by giving examples (e.g., 'Code-Review: +1') and clarifying what 'ready' and 'work-in-progress' mean in the context. This goes beyond the schema's basic property descriptions and aids correct invocation.

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 specific action: 'Post a review on a Gerrit change,' and enumerates concrete uses (voting on labels, cover message, marking ready/WIP). This distinguishes it from sibling tools like post_review_comment, which is focused on comments only, and from other mutations like abandon_change.

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 lists when to use the tool (vote on labels, leave a message, mark as ready/WIP). It does not explicitly exclude alternatives, but the use cases imply the tool is for overall review posting rather than just comments. The mutation warning also clarifies intentional use, though it could name sibling tools like post_review_comment for exclusion.

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

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

With no annotations provided, the description carries the full burden. It explicitly warns 'This is a mutation — use intentionally' and discloses the reply capability. This adds useful behavioral context beyond the schema, though it could further elaborate on side effects 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 three sentences with no unnecessary words. It front-loads the primary purpose and then adds usage guidance and mutation warning 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 lacking annotations and an output schema, the description covers purpose, usage context, and mutation warning. It doesn't explain return values or prerequisites, but given the schema fully documents parameters, this is adequate for a mutation tool.

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

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

Schema description coverage is 100% for all 7 parameters, so the baseline is 3. The description adds context by mentioning 'file/line' and 'reply to existing comments', but does not provide per-parameter details beyond what the schema already specifies.

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 ('Post an inline comment'), the target ('on a specific file/line in a Gerrit change'), and the scope ('line-by-line code review comments'). This distinguishes it from sibling tools like post_review, which is for general review 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?

It explicitly instructs to use this for line-by-line code review comments, providing clear context. It also mentions the ability to reply to existing comments, but does not explicitly state when not to use it or name alternative tools like post_review for general comments.

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

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

No annotations are present, so the description must convey behavior. It states it searches accounts, implying a read-only operation, but doesn't disclose details like pagination, result limits, or case sensitivity. The phrase 'looking up account details' hints at return content but not explicitly.

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

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

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

For a simple search tool with 2 parameters and full schema coverage, the description covers the purpose and common use cases. It lacks an explicit statement about the return value (list of matching accounts), but the tool is simple enough that this is a minor gap.

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

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

Schema coverage is 100%, with both 'query' and 'limit' described. The description echoes the query parameter's acceptable fields (name, username, email) but adds no additional semantic 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 uses the specific verb 'Search' and identifies the resource 'Gerrit accounts' with search criteria (name, username, email). It distinguishes from siblings like get_account by indicating a search rather than a fetch-by-ID.

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 clear context for when to use the tool: 'useful for finding reviewers or looking up account details.' However, it does not explicitly exclude alternatives or state when not to use it, so it doesn't fully reach 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?

No annotations are provided, so the description carries the full burden. It implies a read-only operation through 'Query' and 'Returns a list', but it does not explicitly disclose that no changes are made, or mention permission requirements, error behavior, or pagination defaults. However, the read-only nature is reasonably clear from the verb.

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 succinct and front-loaded with the purpose. It uses two sentences plus a list of useful query examples, with no wasted words or repetition of schema details.

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

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

The description covers the tool's purpose and provides common query examples, while the schema documents all parameters. Although there is no output schema, the statement that it returns a list is sufficient for basic use. It lacks details on response fields, but that is not critical for a query tool.

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

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

The schema already describes all four parameters with examples, giving 100% coverage. The description adds value by providing additional query examples (owner:self, reviewer:self, is:watched) beyond those in the schema, which enriches the semantics of the query parameter without being redundant.

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

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

The description clearly states the tool's function: 'Query Gerrit changes using Gerrit's query syntax' with a specific verb and resource. It also distinguishes from sibling tools like query_accounts and get_change_details by focusing on changes and returning a list.

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

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

The description provides common query examples that imply usage scenarios, but it does not explicitly state when to use this tool versus alternatives such as get_change_details or list_change_files. There is no mention of when-not-to-use or alternative tool recommendations.

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

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

With no annotations, the description must disclose behavior. It explicitly calls out that this is a mutation, which is useful. But it does not mention permissions, failure conditions, or any side effects beyond restoring status, leaving some gaps.

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

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

The description is extremely concise—two short sentences with no filler. It front-loads the primary purpose and immediately follows with a clear warning, making every word earn 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 one-parameter tool, the description covers the core action. However, it lacks reference to the sibling abandon_change tool, error conditions, or any post-restore effects. This is a minimum viable description but not fully complete.

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

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

The schema already provides 100% coverage for the single parameter change_id with detailed format examples. The description adds no additional parameter information, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('restore') with a clear target ('abandoned Gerrit change') and outcome ('back to active status'). This clearly distinguishes it from sibling tools like abandon_change or submit_change.

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 it to restore an abandoned change. The warning 'use intentionally' adds caution. However, it does not explicitly mention alternatives or exclusions, 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?

With no annotations provided, the description carries the full burden. It explicitly warns 'This is a mutation — use intentionally and confirm with the user before calling,' which discloses the destructive/mutating nature and suggests a safety practice. It doesn't mention reversibility or side effects, but the warning is valuable.

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

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

The description is two sentences, front-loaded with the primary purpose, and includes essential caveats without wasted words. 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?

With one parameter, no output schema, and no annotations, the description provides the key elements: purpose, preconditions, and a behavioral warning. It doesn't cover all possible edge cases (e.g., what happens on failure), but for a simple mutation tool it is sufficient.

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 covers the single parameter change_id with a detailed description (numeric, 'project~branch~changeId', or full Change-Id). Since schema coverage is 100%, the description does not need to add parameter meaning. It adds nothing beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action: 'Submit a Gerrit change for merging.' This is a specific verb+resource combination that distinguishes it from sibling tools like abandon_change and restore_change.

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 explicit preconditions: 'must be ready to submit (all required labels approved, no merge conflicts).' It also advises confirming with the user before calling. However, it does not explicitly list alternatives or when-not-to-use scenarios.

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