mcp

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

The description reveals the use of server-side apply, which is a meaningful behavioral trait (conflict handling, ownership semantics). Annotations already indicate idempotent and destructive hints, and the description does not contradict them. It adds value beyond annotations by specifying the apply method, though it doesn't detail 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?

The description is two sentences, front-loaded with the main purpose, and contains no redundant information. The kubectl analogy is valuable and concise.

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

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

Given the presence of a full input schema, annotations, and an output schema, the description provides sufficient contextual information for an agent to select and invoke the tool. It covers the core function and method, and does not need to explain return values due to the output schema.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description adds no additional parameter semantics beyond what's already in the schema, so baseline score 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's function with a specific verb ('Applies') and resource ('Kubernetes manifest'), and distinguishes it from sibling tools by specifying server-side apply and the kubectl analogy.

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 for when to use this tool (applying manifests to a cluster) but does not explicitly mention alternatives or exclusions. The analogy to kubectl apply helps set expectations but doesn't reference other mutation tools like patch_k8s_resource.

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 does not add behavioral context beyond the existing annotations. While annotations already indicate destructive (destructiveHint=true) and idempotent (idempotentHint=true), the description merely restates the tool's function without disclosing side effects, reversibility, permission requirements, or response 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, concise sentence that directly states the tool's purpose. Every word is useful, and there is no extraneous information.

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

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

With full schema coverage, an output schema, and annotations specifying destructive/idempotent behavior, the description is minimally sufficient for invocation. However, it lacks guidance on when to cancel an operation and does not mention state prerequisites or return semantics, leaving some context to the agent's inference.

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 description coverage is 100% for both required parameters, with detailed format specifications in the schema. The description itself adds no additional parameter semantics, 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+resource ('Cancels a specific GKE operation') and clearly distinguishes itself from sibling tools like get_operation and list_operations. It conveys the exact action without ambiguity.

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 checking operation status with get_operation or waiting for completion. The description states only what it does, not the circumstances under which cancellation is appropriate or prerequisites (e.g., operation state).

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, idempotentHint=true, and destructiveHint=false. The description adds value by explaining that it 'checks' rather than performs an action, and the `kubectl auth can-i` analogy further clarifies the read-only, non-mutating nature. No contradictions.

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, focused sentence that front-loads the core purpose and includes a concise analogy. Every word earns its place, and there is no redundancy or 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 tool has 5 parameters with full schema documentation, an output schema, and annotations covering safety. The description succinctly conveys the core function and analogy, which is sufficient for an agent to understand and invoke the tool. No critical context is missing given the tool's simplicity.

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

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

The schema covers 100% of parameters with descriptive text (e.g., verb, resourceType, namespace). The tool description itself does not add parameter-level details, but the schema already provides sufficient meaning. This meets the baseline for full 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 clearly states the tool's purpose with a specific verb and resource: 'Checks whether an action is allowed on a Kubernetes resource.' It also uses a well-known analogy (`kubectl auth can-i`) that reinforces the exact behavior and distinguishes it from sibling tools that perform resource operations like apply, delete, or get.

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 that this is for checking authorization, similar to `kubectl auth can-i`. It does not explicitly name alternatives or exclusions, but the tool is unique among siblings (no other auth-check tool exists), making its usage obvious. The analogy gives practical guidance on when 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 indicate readOnlyHint=false, implying a write operation. The description adds valuable behavioral context beyond annotations by revealing the Autopilot default and the specific field needed to create a Standard cluster. It also notes similarity to gcloud CLI behavior. No contradiction with annotations is present.

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 4 sentences, front-loaded with the primary purpose. The second sentence suggests reading docs, which is somewhat optional, but the Autopilot vs. Standard guidance is essential. Overall, every sentence provides useful information without excessive verbosity.

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 2 well-defined params and an output schema, so return values need no explanation. The description covers the key decision point (Autopilot vs Standard) and points to docs for deeper configuration. It does not mention prerequisites or authentication, but sibling tools like check_k8s_auth and get_cluster provide some context. Sufficient for a creation 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%, with both params clearly described (parent format and cluster JSON resource). The description adds extra meaning to the cluster parameter by explaining that cluster creation defaults to Autopilot and how to configure a Standard cluster. This goes beyond the schema's generic JSON description.

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 'Creates a new GKE cluster in a given project and location,' which is a specific verb+resource. It clearly distinguishes from sibling tools like create_node_pool (node pool creation) and get_cluster/list_clusters (read operations). The reference to equivalent gcloud commands further reinforces its purpose.

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

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

The description gives clear context for the main usage decision: it defaults to Autopilot mode and explains how to switch to Standard by setting autopilot.enabled=false. It also recommends reading GKE documentation for configuration options. However, it does not explicitly mention when not to use this tool or distinguish it from update_cluster or other alternatives, though the purpose is unambiguous from sibling names.

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, and destructiveHint=false, so the write and non-destructive nature is known. The description adds minimal extra behavioral context, only noting the target scope, with no mention of long-running operations or side effects; 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 a single, front-loaded sentence with no redundant words, stating the core action and target clearly.

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 annotations, complete parameter schema, and output schema presence, the description is adequate for a straightforward create operation. It clearly identifies the target resource, and the schema fills in the parameter details; minor omissions like operational duration are not critical when structured fields cover them.

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%: both parent and nodePool have detailed descriptions in the schema. The tool description adds no additional parameter-level semantics, 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 uses the specific verb 'creates', identifies the resource 'node pool', and scopes it to 'a specific GKE cluster', clearly distinguishing it from sibling tools like create_cluster or update_node_pool.

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 use for an existing cluster ('for a specific GKE cluster') but does not explicitly compare with alternatives such as create_cluster or update_node_pool, nor mention prerequisites or when not to use 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?

Annotations already declare destructiveHint=true, so the description doesn't need to restate that. However, it adds no further behavioral context beyond the basic deletion, such as irreversibility, permissions, or side effects. It aligns with annotations and offers no contradictions.

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 main action and a useful analogy. Every word earns its place, 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?

Given the presence of a rich schema and annotations, the description is sufficient for a straightforward delete operation. It omits nuances like dry-run or cascade behavior, but those are captured in the schema. The description is not overly verbose and covers the core purpose.

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 all 6 parameters with descriptions, including required fields and defaults. Since schema coverage is 100%, the description need not add parameter details, and it doesn't—staying neutral. This meets the baseline for high coverage.

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

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

The description clearly states the action ('Deletes a Kubernetes resource from a cluster') and provides a familiar analogy ('similar to running kubectl delete'). It distinguishes from siblings by naming the delete operation, though it does not explicitly compare with alternative 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?

The description offers no explicit guidance on when to use this tool versus alternatives like patch_k8s_resource or apply_k8s_manifest. The kubectl delete analogy implies usage context, but no criteria or scenarios are 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's safe. The description adds that it's 'similar to kubectl describe', which conveys that output is detailed and human-oriented. It does not mention potential large output size or pagination, but given annotations cover the safety profile, this is adequate and adds useful 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, immediately states the core purpose and an analogy. No fluff. Perfectly sized for 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?

Given an output schema exists and annotations indicate a safe read, the description is complete enough for a describe-like operation. It could mention what 'details' includes, but the kubectl describe comparison covers that. For a tool with good structured data, this 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?

Schema description coverage is 100%, so the input schema already documents all five parameters with descriptions. The description itself adds no extra parameter detail. Baseline 3 is appropriate since schema does the heavy lifting; no additional semantics 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 clearly states it 'shows the details of a specific Kubernetes resource' and compares to 'kubectl describe', which is a specific verb+resource. It distinguishes from siblings like get_k8s_resource (which likely returns a summary) and list_k8s_events, but doesn't explicitly contrast with them, so not 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 description implies usage: use when you need detailed information about a resource, similar to kubectl describe. It does not explicitly state when not to use it or mention alternatives, but the analogy to 'kubectl describe' provides context that it's for detailed inspection rather than listing. It lacks explicit exclusions or guidance about when to use get_k8s_resource or list_k8s_api_resources 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?

Annotations already declare readOnlyHint and idempotentHint, and the description aligns with a safe read operation. However, the description adds no extra behavioral context beyond the annotations, such as field masking defaults or pagination behavior, so it meets the baseline without enriching transparency.

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

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

The description is a single focused sentence with no redundant content. Every word contributes to the purpose, achieving maximum 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?

For a simple get operation with a comprehensive input schema, an output schema, and strong annotations, the description is adequate. It lacks explicit differentiation from get_k8s_cluster_info, but the 'GKE cluster' specificity mitigates ambiguity, so it is nearly complete.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The tool description does not add any additional meaning 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 ('Gets') and clearly identifies the resource ('details of a specific GKE cluster'). This distinguishes it from sibling tools like list_clusters or get_node_pool, as it targets a single GKE cluster's details.

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 about when to use this tool versus alternatives such as list_clusters or get_k8s_cluster_info. The description gives no exclusions or explicit context for selection, 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read operation. The description adds the `kubectl cluster-info` analogy, which gives some context about the output behavior, but this is limited beyond what annotations and the word 'Gets' already 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?

The description is two sentences, front-loads the action, and contains no fluff. Every word contributes to understanding what the tool 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?

For a simple one-parameter tool with an output schema and rich annotations, the description is mostly sufficient. However, it lacks differentiation from the sibling `get_cluster`, which could leave the agent unsure which tool to invoke in a given context.

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

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

Schema description coverage is 100% for the single `parent` parameter, including its format. The description does not add any additional parameter information, 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 'Gets' with a clear resource 'cluster endpoint information', and the analogy to `kubectl cluster-info` clarifies the scope. However, it does not explicitly distinguish from the sibling tool `get_cluster`, which might have overlapping functionality.

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 `get_cluster` or `list_clusters`. The `kubectl cluster-info` analogy implies a use case, but it does not provide boundaries 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing a safe read-only operation. The description adds the `kubectl logs` analogy, which provides a familiar behavioral reference but doesn't disclose additional side effects, rate limits, or failure modes. This is adequate but not substantial.

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, focused sentence that clearly states the tool's purpose without redundancy. It is concise and front-loaded, making it 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 description, combined with the comprehensive input schema and strong annotations, provides enough context for an agent to select and invoke the tool correctly. The kubectl logs analogy aids understanding, and the output schema covers return values, so the description doesn't need to explain them. It is complete but not exceptionally detailed.

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 provides detailed descriptions for all 10 parameters, covering their meanings and defaults. The tool description doesn't add any parameter-level semantics beyond the schema. With 100% schema coverage, 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 clearly states the tool's purpose: 'Gets logs from a Kubernetes container in a pod.' The verb 'Gets' and the resource 'logs from a Kubernetes container in a pod' are specific. The comparison to 'kubectl logs' reinforces clarity and distinguishes it from sibling tools like get_k8s_resource or describe_k8s_resource.

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

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

The description provides clear context by likening the tool to `kubectl logs`, making it evident when to use it (retrieving container logs). However, it lacks explicit exclusions or mention of alternative tools (e.g., list_k8s_events for events), so it doesn't fully meet the 'explicit when/when-not' criterion.

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 disclose readOnly, idempotent, and non-destructive behavior, and the description adds only the kubectl analogy and a claim that resources are returned in YAML format. That claim is contradicted by the input schema, which states the default outputFormat is table (YAML is only one enum option), making the behavioral guidance misleading.

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

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

The description is short and front-loaded with the core operation and filter scope. The kubectl analogy is useful context, but the unsupported YAML-format claim keeps it from earning full marks.

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 getter with rich schema and output schema, the description covers the main purpose and filtering behavior. It is incomplete on how this tool relates to sibling tools and contains a misleading output-format statement, so it is only minimally 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?

The schema has 100% parameter description coverage and detailed enum explanations, so the description does not need to carry much parameter meaning. The description reinforces the main filters (type, name, namespace, label selectors) but omits fieldSelector and customColumns; this adds nothing 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 operation ('Gets one or more Kubernetes resources from a cluster') and identifies the resource family and filtering dimensions. However, it does not explicitly differentiate the tool from sibling tools like describe_k8s_resource or get_k8s_logs; the analogy to 'kubectl get' supplies some distinction but not a stated 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 'similar to running kubectl get' analogy gives useful context for when the tool is appropriate, and the filter list hints at its scope. The description never says when to prefer this tool over siblings such as describe_k8s_resource or list_k8s_api_resources, nor does it mention exclusions or prerequisites such as cluster auth.

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, idempotentHint=true, and destructiveHint=false, which the description's 'Checks' aligns with. The description adds the notion of 'current' status, which implies a point-in-time check rather than a blocking wait, but it does not elaborate on whether the call waits for rollout completion or returns immediately, leaving potential ambiguity given the kubectl analogy.

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 core purpose in the first sentence, and uses the second sentence for a helpful analogy. Every word earns its place, with no redundant 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 a simple read-only operation with complete schema coverage, clear annotations, and an output schema. The description sufficiently orients the agent, and the kubectl analogy adds relevant context. No significant gaps exist for a tool of this 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?

The input schema has 100% coverage with detailed descriptions for all four parameters, so the schema carries the full semantic burden. The description provides no additional parameter-level details, which is acceptable given the schema's completeness; baseline 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's function: 'Checks the current rollout status of a Kubernetes resource.' It includes a specific verb ('checks') and resource ('rollout status'), and the kubectl analogy ('similar to running `kubectl rollout status`') precisely conveys the intended operation, distinguishing it from generic get/describe tools.

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

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

The kubectl analogy gives implicit guidance on when to use the tool (when you would run `kubectl rollout status`), but it does not explicitly mention alternatives or exclusion criteria among sibling tools. No when-not-to-use guidance is provided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful context by specifying that both client and server versions are retrieved and by comparing it to `kubectl version`, giving the agent a clear mental model of behavior beyond the annotations. No contradictions.

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 the action front-loaded. It provides no redundant information and every word adds value. The analogy to `kubectl version` is a useful explanatory touch without bloating the text.

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 getter with an output schema, the description is complete. It clearly states what is retrieved and for which resource, while the schema handles the parameter format and the output schema covers return values. No additional context is necessary.

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 description covers 100% of the parameter, including the required format for `parent`. The tool description itself does not add parameter-specific details, but the schema already provides full semantics. With high schema coverage, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves Kubernetes client and server versions for a cluster, using the specific verb 'retrieves' and a clear resource (versions). The similarity to `kubectl version` reinforces its purpose and distinguishes it from siblings like get_cluster or get_k8s_resource, which focus on other aspects.

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

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

The description provides clear context: it is used to get Kubernetes version information for a given cluster, analogous to `kubectl version`. While it doesn't explicitly name alternatives or state when not to use it, the narrow scope makes its use case unambiguous. The absence of exclusions is acceptable for a simple read-only getter.

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 idempotentHint=true, and the description 'Gets' is consistent with a safe read operation. The description adds minimal behavioral context beyond the scope ('specific node pool' vs list), but it doesn't disclose return format or error behavior. Since annotations cover the safety profile, this is acceptable 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 a single, front-loaded sentence with no filler words. It communicates the essential action and resource in under 20 words, perfectly sized for a simple getter tool.

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

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

Given the single parameter fully documented in the schema, strong annotations, and presence of an output schema, the description is mostly complete. However, it lacks any usage guidance relative to sibling list/get tools, which would make it more helpful. For a simple getter, this is a minor gap, so a score of 4 is appropriate.

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 provides 100% coverage for the sole parameter 'name,' including the exact resource format. The description adds no additional parameter semantics, so it relies entirely on the schema. This matches the baseline for high 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 uses the specific verb 'Gets' and identifies the resource as 'details of a specific node pool within a GKE cluster.' This clearly distinguishes it from list_node_pools and get_cluster, making the purpose unambiguous.

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

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

The description implies usage when you need details for one specific node pool, but it does not explicitly state when to use this tool over siblings like list_node_pools or get_cluster. There is no explicit when-not or alternative naming, so guidance is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds no behavioral context beyond that, such as return behavior, error cases, or resource implications, providing no extra disclosure beyond the structured fields.

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 directly states the tool's purpose. No filler or 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 the simple one-parameter schema, strong annotations, and presence of an output schema, the description is fully adequate. It tells the agent what the tool does and the schema covers invocation details, so no further context is needed.

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 single parameter 'name' is well-documented with format details. The description adds no parameter-specific meaning beyond what the schema already provides, 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 ('Gets') and resource ('details of a specific GKE operation'), clearly distinguishing it from sibling tools like list_operations or cancel_operation. It states exactly what the tool does with no ambiguity.

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 retrieving a single GKE operation by name, which is clear context. However, it does not explicitly mention alternatives or when not to use it, such as 'use list_operations to list all 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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description adds no additional behavioral context. The location semantics are already present in the schema's parent parameter description, so repeating them provides no extra value. The description does not mention pagination, response size, or other operational details.

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 verb and resource, then adds essential scope information about location. There is no wasted text or 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-only list tool with rich annotations and an output schema, the description adequately covers the core purpose and location flexibility. It lacks explicit guidance on alternatives, but overall it is sufficiently complete for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, with detailed descriptions for both parent and readMask. The description itself adds no parameter meaning beyond what the schema already provides, 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 clearly states the specific action 'Lists GKE clusters' with scope 'in a given project and location', and further clarifies location semantics including '-' for all locations. This distinguishes it from sibling tools like get_cluster (single cluster) and list_node_pools (node pools).

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

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

The description implies when to use: to list GKE clusters in a project/location, and explains the required parent/location format. However, it does not explicitly name alternatives or exclusion criteria, such as using get_cluster for a single cluster.

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 idempotentHint=true, so the safety profile is clear. The description adds the kubectl analogy and scope, but no extra behavioral details (e.g., whether it requires specific permissions or list pagination). With annotation coverage, 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 that both earn their place: the first states the core action and object, the second gives a useful analogy. No filler or redundant wording.

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 listing tool with one parameter, strong annotations, and an output schema. The description provides sufficient context for an agent to select and invoke it correctly; nothing important 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 100% and the sole parameter 'parent' is fully documented in the schema with format guidance. The tool description adds no additional parameter semantics, so the baseline score 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 uses a specific verb ('Retrieves') and resource ('available API groups and resources from a Kubernetes cluster'), and the analogy to `kubectl api-resources` makes the purpose unmistakable. It clearly distinguishes this from sibling list tools like list_clusters or list_k8s_events.

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 to use it (to discover API groups and resources) and the analogy to kubectl api-resources provides a familiar reference. However, it does not explicitly mention alternatives or when not to use it, falling short of full 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 already cover the safe read-only, non-destructive, idempotent nature. The description adds the `kubectl events` analogy, which helps the agent predict command-like behavior and output style. It does not contradict annotations and adds value beyond the structured fields.

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 the primary purpose front-loaded and an illustrative analogy in the second. Every word earns its place; no filler or 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 output schema exists and the input schema fully documents parameters and defaults (e.g., limit 500, namespace default). The description is minimal but sufficient for a simple list operation. It could mention whether it supports cross-namespace or cluster-wide events, but that's already in the schema. The analogy to kubectl events adds practical context.

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

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

Schema description coverage is 100%, so the schema fully documents all six parameters. The description adds no additional parameter semantics beyond the `kubectl` analogy, which only loosely implies filtering options. Baseline 3 is appropriate since the schema carries the load.

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 ('Retrieves') and resource ('events from a Kubernetes cluster'), clearly distinguishing it from sibling tools that retrieve logs, resources, or API resources. The analogy to `kubectl events` reinforces the tool's function.

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 use for fetching Kubernetes events via the `kubectl` analogy, but it does not explicitly state when to prefer this tool over alternatives like get_k8s_logs or describe_k8s_resource. There are no stated exclusions or alternative references, so guidance is only implicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the cluster-scoping constraint but does not disclose pagination, ordering, or handling of empty results; with annotations covering the safety profile, a 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?

The description is a single, front-loaded sentence that conveys the essential purpose without any filler. Every word earns its place.

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

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

For a simple one-parameter list operation with rich annotations and an output schema, the description is complete. The agent has enough information to select and invoke correctly.

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

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

Schema description coverage is 100% for the single 'parent' parameter, which documents the required format. The description adds little beyond saying 'specific GKE cluster', which is already implied by the schema. Baseline 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?

Description clearly states the action ('Lists') and the target resource ('node pools for a specific GKE cluster'). This distinguishes it from sibling tools like get_node_pool (which fetches a single pool) and create/update node pool tools.

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

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

The verb 'Lists' implies this is for enumerating node pools, and the scope 'for a specific GKE cluster' indicates prerequisite context. However, no explicit alternative is mentioned (e.g., 'use get_node_pool for a single pool'), so guidance is only implied.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable behavioral context, specifically that the location parameter accepts a region, zone, or '-' for all locations, and that listing is scoped to a given project and location. No contradictions 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 a single, front-loaded sentence that directly states the core functionality and the most important usage nuance (location wildcard). There is no redundant or extraneous information, making it highly concise 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 is simple (one parameter, read-only) and the output schema exists, so return-value details are covered externally. The description conveys the essential purpose and the key location behavior. A small gap is the lack of any mention of pagination or whether only active operations are returned, but these may be addressed by the output schema, and the simplicity of the tool keeps it mostly complete.

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

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

Schema description coverage is 100% for the 'parent' parameter, with detailed format ('projects/*/locations/*') and explanation of '-' wildcard already provided in the schema. The tool description paraphrases the location flexibility but adds little new semantic value beyond what the schema already documents, 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 ('Lists') and identifies the exact resource ('GKE operations') and scope ('in a given project and location'). It clearly distinguishes from sibling tools like get_operation (single operation) and cancel_operation (mutation) by focusing on the listing behavior.

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 clarifies the scope (project and location) and notes the wildcard '-' for all locations, which implies when it might be used (e.g., to list across all zones/regions). However, it does not explicitly mention when to use this tool versus alternatives like get_operation, leaving the usage context somewhat implied rather than spelled out.

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 disclose destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the description does not need to repeat these. The description adds minimal behavioral context beyond the kubectl analogy; it does not explain side effects or requirements. This is adequate given the annotations, but not especially 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 short sentences that are front-loaded with the core action and immediately provide a useful analogy. Every word contributes; 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?

Given the rich input schema (100% parameter coverage) and annotations (destructiveHint, readOnlyHint), the description is succinct but sufficient. The analogy to `kubectl patch` provides practical context for users familiar with Kubernetes tooling. It does not explain all nuances (e.g., patch types), but these are covered in the schema, and an output schema exists.

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 parameters with descriptions, so the baseline is 3. The description itself adds no parameter-level details, but this is acceptable because the schema fully documents each parameter (e.g., patchType valid values, namespace default).

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

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

The description clearly states the tool's function: 'Patches a Kubernetes resource.' The verb 'patch' is specific and distinguishes it from sibling tools like apply_k8s_manifest, delete_k8s_resource, and get_k8s_resource. It also adds the apt comparison to `kubectl patch`, reinforcing the operation type.

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 via the analogy to `kubectl patch`, suggesting it's for partial updates to existing resources. However, it does not explicitly state when to use this tool over apply_k8s_manifest or other alternatives, nor does it provide exclusions. The 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?

Annotations already disclose destructiveHint=true, readOnlyHint=false, and idempotentHint=true, so the safety profile is covered. The description adds no additional behavioral context (e.g., permission requirements, side effects). It is consistent with annotations but does not enrich the transparency beyond 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 description is a single, front-loaded sentence with no redundancy or filler. Every word contributes to meaning, making it highly concise and appropriately 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?

Given the rich schema descriptions, output schema, and annotations, the one-line description is mostly sufficient to identify the tool and its purpose. However, it does not clarify the nature of the update (e.g., full replacement vs. partial patch), which would be useful 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%, with both 'name' and 'update' having descriptive explanations in the input schema. The tool description itself mentions no parameter details, but the schema carries the full burden, so a baseline score 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 states a clear verb ('updates') and a specific resource ('GKE cluster'), distinguishing it from sibling tools like update_node_pool or create_cluster. The word 'specific' reinforces the targeted single-cluster operation, making the purpose 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?

No guidance is provided about when to use this tool vs alternatives such as patch_k8s_resource or update_node_pool. The description only states what it does, with no prerequisites or exclusions, leaving the agent without contextual decision support.

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 no behavioral context beyond the annotations. Annotations already indicate a mutating, destructive, idempotent operation, and the description merely restates 'updates' without detailing potential side effects like node replacement or whether the update is partial or full.

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 filler. It is front-loaded and efficiently conveys the tool's core purpose.

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

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

The description, combined with the full input schema and output schema, is adequate but lacks contextual richness. It doesn't mention when to choose this over create/delete node pools or any caveats about the update request, leaving some ambiguity.

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 does not explain parameters, but the input schema provides complete descriptions for both required parameters (name and update). Since schema coverage is 100%, the description adds no 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 identifies the tool as updating a node pool in a GKE cluster, using a specific verb and resource. It distinguishes from sibling tools like create_node_pool and get_node_pool, though it doesn't elaborate on the types of updates possible.

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 such as update_cluster or create_node_pool. No prerequisites, exclusions, or scenarios are mentioned.

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