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

With no annotations, the description carries the burden. It discloses the mutating nature of the operation and the 'explicit confirmation' guardrail, which is useful. However, it does not explain whether the commit is pushed, what happens on failure, or other side effects.

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-load the core action and then add the key guardrail. 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?

For a basic four-parameter Git commit, the description covers the essentials but omits the return format and any remote/push behavior. It also does not place the tool among its siblings, so an agent gets limited orientation beyond the action itself.

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%, so the description must compensate. It clarifies 'paths' as 'selected files' and 'confirm' as 'explicit confirmation', but repositoryPath and message remain effectively undocumented. Their names make them inferable, which keeps this at a passing score.

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 'Stage selected files and create a Git commit', giving a specific verb and resource. This clearly sets it apart from read-only siblings like repository_diff and repository_status and from higher-level create_pull_request/deploy_repository.

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 operation is self-evidently for committing local changes, but the description gives no explicit guidance about when to choose it over create_pull_request or deploy_repository, and no exclusions are mentioned. Usage is 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?

With no annotations, the description carries the full behavioral burden. It explicitly discloses the main side effects: pushing the current branch, opening a GitHub pull request, using gh, and requiring explicit confirmation. It stops short of covering failure modes or authentication prerequisites, but the disclosed behaviors are significant.

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 confirmation requirement is stated immediately after. Every clause 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 primary purpose and side effects, but with no output schema and no annotations it leaves contextual gaps: what happens on failure, whether gh must be authenticated, which branch is used as the source, and what the tool returns. It is adequate but not fully complete for a mutating external tool.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not. It only hints that confirmation is required, which maps to the confirm parameter, and gives no meaning for repositoryPath, title, base, or body. The defaults in the schema do some work, but the description itself adds almost no parameter-level 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 phrase: 'Push the current branch and open a GitHub pull request using gh.' This clearly identifies the action and resource, and it is easily distinguishable from sibling tools like repository_diff or commit_repository.

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 (when a GitHub PR needs to be opened) but does not explicitly name alternatives or state when not to use it. It does add a usage condition: 'Requires explicit confirmation.' No exclusions or alternative routing are provided.

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

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

The description discloses that the tool requires explicit confirmation, which is a meaningful behavioral trait. However, with no annotations provided, the description carries the full burden for behavioral disclosure; it does not mention side effects, whether the command is destructive, or what happens on failure. The confirmation requirement is a useful addition but not comprehensive.

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

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

The description is a single sentence that is efficient and front-loads the action. It earns its place by stating the core behavior and the confirmation requirement, though it could add a bit more context without becoming verbose.

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

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

For a tool that runs a configured command (likely a mutation with side effects), the description is thin. There is no output schema, no annotations, and no parameter documentation, so the agent lacks information about return values, failure modes, or the nature of the deploy command. The confirmation requirement is helpful but insufficient for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the two parameters. It does not explain what 'confirm' means beyond the schema's boolean type and default false, nor does it clarify the format or semantics of 'repositoryPath'. The description adds no parameter-level 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 states a specific verb ('Run') and resource ('the configured MCP_DEPLOY_COMMAND in a repository'), which clearly identifies the tool's action. It does not explicitly differentiate from siblings like commit_repository or create_pull_request, but the deploy command concept is distinct enough.

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 this tool is for deploying a repository via a configured command, and the confirmation requirement suggests it should be used when the user explicitly wants to deploy. It does not explicitly state when not to use it or name alternatives, 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?

Annotations are absent, so the description carries the full burden. It does not disclose that this is a read-only scan, how directory traversal works, or what happens with maxDepth; only the schema hints at depth limits. The 'allowed directory' constraint is mentioned but not explained.

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 concise single sentence with no filler, front-loading the core action and resource. It is efficient, though slightly under-specified for full standalone clarity.

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

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

With no annotations, no output schema, and minimal description, the tool lacks behavioral context and usage guidance. It is minimally viable but incomplete for an agent needing to understand permissions, depth semantics, or when to prefer this 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 50%: root is documented in the schema, but maxDepth has no description in either the schema or the tool description. The description adds no parameter-level meaning and fails to compensate for the undocumented maxDepth.

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 action ('Find') and resource ('Git repositories'), with a scope constraint of 'below an allowed directory'. It is naturally distinct from mutation-oriented siblings like commit_repository or deploy_repository, though it does not explicitly name a specific alternative.

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

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

No guidance is given about when this tool should be used versus siblings or what prerequisites apply. The phrase 'allowed directory' hints at a permission boundary but does not explain when to invoke listing versus other repository operations.

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 clearly states the tool is non-mutating ('without changing files'), which is valuable. However, it doesn't disclose what the diff output looks like, whether it includes untracked files, or any side effects like refreshing the index.

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 is front-loaded with the action and resource, and immediately clarifies the non-mutating nature. 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 tool with no annotations, no output schema, and zero parameter documentation, the description is too thin. An agent cannot tell what the diff includes, how staged affects results, or what the return value looks like. The read-only guarantee is helpful but not 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?

Schema description coverage is 0%, so the description must compensate for the two parameters. It does not explain what 'staged' means or what format repositoryPath should take. The description adds no parameter-level meaning beyond the schema's bare names and types.

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

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

The description states a specific verb ('Read') and resource ('repository diff') and explicitly notes it does not change files, which distinguishes it from mutation siblings like commit_repository and deploy_repository. It doesn't name a sibling alternative, but the read-only framing is clear enough.

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 this is for inspecting changes without modifying the repository, which is useful context. However, it doesn't explicitly say when to use this over repository_status or commit_repository, nor does it mention the staged parameter's role in selecting what diff to read.

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. The verb 'Show' clearly implies a read-only operation with no side effects. It does not mention permissions or any additional behavior, but the action is unambiguous for a status tool.

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

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

A single sentence with zero fluff. The key actions are front-loaded, and every word contributes to understanding the tool's purpose.

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

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

For a simple tool with one parameter and no output schema, the description covers the essential behavior. It lacks explicit read-only confirmation, but the verb 'Show' is sufficient. No critical information 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 0%, so the description must compensate. It only references 'a repository' without explaining the format, required nature, or validation of repositoryPath. The parameter's meaning is minimally implied but not elaborated.

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 'Show' and the specific resource: current branch, porcelain status, and recent commit. This distinguishes it from siblings like repository_diff (which shows diffs) and commit_repository (which commits changes).

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 checking repository state, but it does not explicitly state when to use it vs. alternatives like repository_diff or list_repositories. No exclusions or conditions are provided, leaving the agent to infer context.

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