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

Annotations already declare readOnlyHint=true and openWorldHint=false, covering the safety profile. The description adds the detail that the result includes status, container state, and conditions, which gives useful foresight about what the agent will receive. It does not disclose any additional behavior such as error conditions or formatting conventions, but given the annotations, the bar is lower and the description 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 a single, front-loaded sentence that immediately identifies the action and resource scope. Every word contributes meaning; there is no filler, preamble, or redundant repetition of tool name or schema fields.

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 has a defined output schema, it is not necessary to describe the return values further. The annotations cover read-only behavior, and the required parameters are standard context selectors. The description provides enough about the operation for it to be invoked correctly. A minor gap is the lack of any mention of what happens if the pod doesn't exist, but that is not essential for selection.

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

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

Input schema has 0% description coverage for its three required parameters. The description mentions 'Pod' but does not explain that 'name' refers to the pod name, nor clarify cluster or namespace format. While the parameter names are self-explanatory in a Kubernetes context, the description does not compensate for the missing schema descriptions, leaving some ambiguity for agents unfamiliar with the tool's conventions.

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 operation ('Return') and the specific resource ('a Pod'), and enumerates the content: 'detailed status, container state and conditions'. This distinguishes it from the sibling list-oriented tools (list_clusters, list_api_resources), which operate on collections rather than a single pod.

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 you need detailed status of a specific pod rather than a list of resources. However, it does not explicitly mention alternatives or give any 'when not to use' guidance. The context is clear enough for a knowledgeable agent but the guidance is 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds what the tool returns (version, node readiness summary) but does not disclose behavior around invalid contexts, unreachable clusters, or partial results. 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 a single, efficient sentence that front-loads the verb and the key output. Every word adds meaning, with 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?

With an output schema present, return-value details are not necessary. The description is mostly sufficient for a one-param tool, but the sole required parameter, cluster, is not fully explained in terms of value source or format. This leaves a small but real gap in callability.

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 clarifies that the cluster parameter refers to 'one context,' but does not explain what values are valid, how to obtain them, or the expected format. This leaves the required parameter underspecified.

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

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

The description names a specific verb (Get), a specific resource (Kubernetes version and node readiness summary), and a clear scope (one context). This distinguishes it from siblings like list_clusters and list_nodes, which are list-oriented rather than health-summary-oriented.

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 explicit guidance on when to use this tool versus alternatives such as list_nodes or list_clusters. The phrase 'for one context' implies it takes a cluster identifier, but the description does not say when this tool should be preferred or when a sibling tool would be more appropriate.

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

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

Annotations declare readOnlyHint=true, and the description's 'Read' is consistent with that. The extra warning to 'Review returned data for sensitive values' adds behavioral context beyond the annotations, telling the agent that output may contain sensitive content.

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, no filler, with the core action front-loaded and the usage warning kept separate. 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?

The tool is simple, has an output schema, and the description covers purpose plus a meaningful sensitivity caveat. It does not mention error conditions or how cluster/namespace are resolved, but for this lightweight read operation the description is 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?

Schema description coverage is 0%, and the description adds no parameter-level meaning beyond the bare names 'cluster', 'namespace', and 'name'. The parameter names are fairly obvious, but the description does not help disambiguate expected values or format.

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'), a specific resource ('ConfigMap'), and a clear scope ('including its data'). This clearly distinguishes it from generic tools like get_resource and from list_* sibling tools.

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

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

The description implies the tool is for reading ConfigMaps when you need their data, but it never explicitly names alternatives or says when not to use it. There is no mention of get_resource or list_secrets as alternatives, so usage 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, which the description matches ('Read...'). It goes beyond the annotations by warning that logs 'may contain sensitive application data' — a genuinely important behavioral disclosure — and by stating the read is a 'bounded tail', so the agent knows it is not streaming or fetching the entire log. 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?

Two short sentences, front-loaded with the verb and resource; both sentences earn their place, including the sensitive-data warning. Slightly under-sized for the parameter complexity, hence not a 5.

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 covers return values and annotations cover the safety profile, so the description does not need those. Given 0% schema parameter coverage, however, the description leaves the meaning of previous, container, and tail_lines largely implicit and gives no sibling routing guidance. Adequate minimum, with clear gaps.

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

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

Schema description coverage is 0%, so the burden falls on the description. It only hints at tail_lines ('bounded tail') and container ('container logs'); it says nothing about how cluster, namespace, name, previous, or container behave (e.g., null container meaning all containers, previous referring to previous pod incarnation). For a 6-param tool this is insufficient compensation.

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') + resource ('container logs') + a key qualifier ('bounded tail') that clearly distinguishes it from sibling read tools like describe_pod, get_resource and list_pods. An agent can tell this is log access, not resource inspection or listing.

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 prefer get_pod_logs over describe_pod, get_resource, or list_resources, and no indication of the crash-debugging use case that the 'previous' flag serves. The description is not misleading, but it leaves all routing decisions to the agent.

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 readOnlyHint=true annotation already communicates the read-only safety profile, and the description is consistent with that. The description adds little beyond 'Get any Kubernetes resource object'; it does not disclose error behavior, cluster handling, or optional namespace semantics, but for a simple getter this is a moderate gap.

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

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

The description is a single focused sentence with no filler. It front-loads the verb and object and keeps the essential parameter mention in order, 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 output schema and read-only annotation reduce the need to describe return values or safety, but the description still relies heavily on Kubernetes domain knowledge. It does not explain the required cluster parameter, the optional namespace, or how to discover valid apiVersion/kind combinations, so a less experienced agent could struggle to invoke it correctly.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It mentions apiVersion, kind, and name, but omits cluster and namespace entirely, and does not clarify apiVersion formats or namespace default null behavior. This partial coverage is not enough to compensate for the absent schema descriptions.

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

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

The description clearly states the action ('Get') and the broad resource ('any Kubernetes resource object'), and identifies the key locators: apiVersion, kind, and name. It is distinguishable from siblings like get_configmap and describe_pod because it is explicitly generic, though it does not name those alternatives.

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

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

The description implies when to use it: when you need a specific Kubernetes object by apiVersion, kind, and name. It gives no explicit guidance on when not to use it or when to prefer a sibling like list_resources or describe_pod, so the usage context is present but not fully developed.

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 openWorldHint=false, covering the read-Only and closed-world behavior. The description adds that CRDs are included and only queryable resources are returned, but it does not disclose response format, pagination, or whether it returns all API versions. 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?

A single sentence with no filler and the key phrase 'Kubernetes API resources' placed up front. It is appropriately brief for a simple discovery tool, though it misses an opportunity to mention filtering or alternatives.

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 large sibling set and absence of an output schema, the description leaves selection criteria unaddressed and does not clarify that the result is a list of resource types. It is minimally viable but incomplete for reliable tool choice.

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 three parameters (cluster, kind, api_version) with no descriptions. The tool description does not explain how these parameters filter the discovery, whether kind or api_version narrow the result set, or what formats are accepted. Parameter names are somewhat self-explanatory, but 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 ('Discover') and a resource ('Kubernetes API resources, including CRDs'), which makes the core purpose clear: enumerate queryable resource types rather than actual resource instances. The reference to CRDs helps distinguish it from tools that list concrete resources, though it could more explicitly say it returns API resource types.

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 when-to-use or alternative guidance is provided. With many sibling list_* tools such as list_crds and list_resources, the description does not tell an agent when to select this tool over them. The usage context is only implied by the phrase 'that can be queried.'

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

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

The annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful context by specifying that the output is limited to items skipped due to duplicate contexts, but it does not describe return behavior beyond that, and no pagination or formatting details are mentioned.

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 entire description is one short, front-loaded sentence that names the action, the resources, and the condition. Every word carries meaning, with 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 parameterless read-only list tool with an output schema, the description covers the essential purpose and scope. It might have been slightly richer with a note about why duplicate contexts cause skipping, but nothing required for invoking the tool is missing.

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

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

The input schema has zero parameters, so there are no parameter semantics for the description to clarify. The baseline for a zero-parameter tool is 4, and the description does not need to compensate for any schema gaps.

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

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

The description names the verb 'List' and specific resources ('contexts and kubeconfig files') with a precise scope: items 'skipped due to duplicate contexts.' This clearly distinguishes it from sibling list_* tools that list active resources, so an agent can identify what this tool is for without opening a schema.

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 a use case: when the agent needs to inspect kubeconfig entries that were skipped because of duplicate contexts. However, it does not explicitly state when to prefer this tool over other list_* tools, nor does it give any exclusions or alternative tool 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?

The readOnlyHint=true already establishes that this is a safe read operation, and the description adds the scope detail that all installed CRDs are returned along with served versions. It does not describe pagination, error behavior, or permission requirements, but for a read-only list tool with annotations present, 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 a single concise sentence with the verb and resource front-loaded. There is no redundant filler or repetition of schema or annotation 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 output schema and read-only annotation cover significant ground, and the description clearly states the tool's purpose. However, the required cluster parameter is undocumented and no sibling differentiation is provided, leaving an agent with moderate gaps before it can invoke the tool confidently.

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 documenting the required 'cluster' parameter, but it does not. The parameter name offers some semantic hint, but the description gives the agent no guidance on acceptable values or how cluster identity relates to listing CRDs.

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 action ('List') and a precise resource ('installed CustomResourceDefinitions') with the additional detail that served versions are included. However, it does not explicitly distinguish itself from sibling tools such as list_api_resources or list_resources.

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

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

There is no guidance on when to use this tool versus alternatives like list_api_resources or list_resources, and no exclusions are given. The usage context must be inferred entirely from the tool name and description.

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

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

Annotations already mark readOnlyHint=true, and the description's 'List' is consistent with that. It adds the useful 'replica readiness' detail, but doesn't cover pagination, error behavior, permission needs, or namespace semantics. No annotation contradiction.

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 entire description is a single front-loaded sentence with no filler. Every word adds value.

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

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

For a simple read-only list tool with an output schema, the description covers the core purpose. However, missing parameter semantics and usage guidance leave ambiguity about the required cluster parameter and how namespace filtering behaves.

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

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

Schema description coverage is 0%, and the description does not explain either 'cluster' or 'namespace' beyond their raw names. The description fails to compensate for the low schema coverage.

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

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

Description uses a specific verb ('List') and resource ('Deployments'), and adds 'replica readiness' as a distinguishing aspect. It clearly differentiates from sibling list tools by naming a concrete resource 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?

No explicit guidance on when to use this tool versus alternatives such as list_resources or list_statefulsets. There are no stated conditions, exclusions, or preferred scenarios.

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 readOnlyHint annotation already communicates that this is a safe read operation, so the description's added value is limited to stating the event categories included and the sort order. It does not contradict the annotations, but it also does not disclose potential limits, pagination, or more detailed runtime 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 front-loads the key action and resource, then adds the two most important qualifiers: event types and ordering. There is no filler or redundant phrasing.

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 core behavior is stated and an output schema is present, so return values need no explanation. However, the description leaves 'recent' ambiguous relative to the hours parameter and does not clarify that namespace filtering is optional, creating a small but real gap for an agent planning the 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 carries the burden of explaining parameters. It only hints at the time window with the word 'recent,' leaving hours and the meaning of cluster and namespace mostly to inference from their names and schema defaults.

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

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

The description uses a specific verb and resource: it lists Kubernetes events, and it adds meaningful scope by specifying that both warning and normal events are returned, newest first. This clearly distinguishes it from sibling list tools, none of which target Kubernetes 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 does not say when to prefer this tool over alternatives, nor does it mention any prerequisites or exclusions. The purpose implies use when Kubernetes events are needed, but there is no explicit usage guidance beyond the bare description.

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

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

The readOnlyHint annotation already signals that this is a safe read operation, and the description is consistent with it. The description adds the useful detail that phases are returned, but it does not explain behavior such as cluster scoping, ordering, or pagination; it provides modest context beyond the annotations.

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

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

The description is one compact, front-loaded sentence with no filler or redundant material. It covers the action and the unique output detail efficiently, which is appropriately concise for a simple 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?

With one required parameter, readOnly annotations, and an output schema, this is a low-complexity tool. The description captures the core operation and the phase output, and the required cluster parameter is inferable as the scoping value; the main gap is that this relationship is not stated explicitly.

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 says nothing about the required cluster parameter. The title 'Cluster' gives minimal meaning, yet there is no guidance on valid values or how the cluster is used to select namespaces.

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 action ('List'), a target resource ('namespaces'), and an output detail ('their phases'), making the purpose immediately clear and distinguishable from generic siblings like list_resources. It loses a point because it does not mention that namespaces are scoped to the required cluster parameter, leaving some ambiguity about the listing 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 wording implies the tool should be used when an agent needs a list of namespaces with their phase/status. It does not name any alternatives or when-not-to-use conditions, so it gives only implicit guidance rather than explicit routing to a sibling 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 readOnlyHint=true, so no need to state that. The description adds some behavioral context by noting that node readiness, roles, version, and pressure conditions are returned, which goes beyond a generic 'list nodes'. However, it doesn't clarify how the cluster parameter scope or whether any filtering applies.

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 wasted words. It immediately states the action and the useful detail of what is listed.

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 simple tool definition is adequate: annotations cover safety, an output schema exists, and the description conveys the core purpose. But the lack of usage guidance and parameter elaboration leaves meaningful gaps for an agent trying to decide when and how to use it correctly.

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

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

The schema has one required parameter, 'cluster', with 0% description coverage. The tool description doesn't mention 'cluster' at all, leaving its meaning and accepted values ambiguous. There is no compension for the lack of schema documentation.

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

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

The description states a specific verb ('List'), a clear resource ('nodes'), and explicitly names the information included (readiness, roles, version, pressure conditions). This clearly distinguishes it from siblings that target other resources like clusters, pods, deployments, and configmaps.

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 when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives or exclusions, so an agent must infer when to choose this over list_clusters or get_cluster_health.

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

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

Annotations already mark the operation as readOnly and not open-world, so the description does not need to restate safety. It adds the filtering behavior around failure signals but nothing about pagination, output limits, or interpretation of failure signals.

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

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

One concise sentence with the main action front-loaded and no 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 read-only listing tool with an output schema, the description is minimally viable but leaves 'failure signals' undefined and gives no guidance on the required cluster parameter. It is not seriously incomplete, but clear gaps remain.

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 bears the burden of explaining parameters. It only implies the meaning of problems_only via 'failure signals'; cluster and namespace receive no semantic explanation beyond their names.

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

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

The description names a clear verb and resource, 'List Pods', and adds an optional filter for failure signals. It does not explicitly contrast with sibling tools such as describe_pod or list_resources, so it is 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 phrase 'optionally restricting results to Pods with failure signals' implies a use case for the problems_only flag. However, it does not state when to prefer this tool over list_resources or describe_pod, nor any 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, so the description does not need to re-state that this is a read operation. The phrase 'as metadata' adds a mild behavioral hint about return depth, but the description does not disclose namespace/cluster scoping behavior, pagination, or potential permission requirements. This is acceptable given the read-only annotation, 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 a single dense sentence with no filler or redundancy. It front-loads the core action and resource types, and every word adds meaning. While terse, that terseness is not tautological; it is information-dense.

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 by design and has an output schema, so return-value documentation is not strictly needed. However, with two parameters and zero schema descriptions, the missing parameter semantics and lack of usage guidance leave the agent without enough information to call the tool confidently. The description is too sparse to be complete.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter semantics, but it never mentions 'cluster' or 'namespace'. An agent cannot tell what values are valid for cluster, how namespace filters results, or whether namespace is required for some resources. This is a significant gap.

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

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

The description names four specific resource types (Roles, RoleBindings, ClusterRoles, ClusterRoleBindings) and uses the verb 'List', making the tool's purpose explicit. It is clearly distinguishable from sibling list_* tools like list_pods, list_nodes, or list_crds because it targets RBAC metadata specifically.

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 by naming RBAC resources, but it gives no explicit guidance about when to choose this over alternatives or when not to use it. Sibling tools like list_resources or get_resource could overlap, and no routing information 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, so the description need not restate safety. The description adds that discovery uses apiVersion/kind, which is a mild behavioral detail. It does not mention pagination, selectors, or namespacing behavior, but the read-only annotation covers the main risk profile.

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

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

A single sentence with no filler, and the key scoping information comes first. It is appropriately concise, though it leans toward terse and omits useful context that would not hurt readability.

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

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

The tool has 8 parameters and zero schema descriptions, yet the description provides almost no context for how to invoke it correctly. An output schema exists, so return values are covered, but param semantics, pagination, selection, and when to choose this over sibling list tools remain unclear.

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

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

With schema description coverage at 0%, the description must compensate, but it only hints at api_version and kind as the discovery mechanism. It says nothing about cluster, namespace, label_selector, field_selector, limit, or continue_token, leaving most of the 8 parameters semantically unexplained.

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 ('List') and a clear resource scope: 'any Kubernetes resource kind'. It also names the discovery mechanism ('apiVersion/kind'), which distinguishes it from sibling tools like list_pods or list_nodes that target specific kinds. The generic scope is immediately apparent.

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

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

The phrase 'any Kubernetes resource kind' implies this tool is for arbitrary resource types, suggesting it is an alternative to sibling-specific listers. However, there is no explicit guidance about when to prefer this tool over list_pods, list_nodes, or get_resource, nor any exclusions or conditions.

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

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

Annotations already declare readOnlyHint=true, but the description adds valuable behavioral context by explicitly noting that Secret values are never returned. This prevents the agent from expecting sensitive data and clarifies the tool's safety boundary beyond what the annotation alone provides.

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 well-structured sentence that front-loads the action and immediately adds the key constraint about Secret values. 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 metadata-listing tool with an output schema and read-only annotation, the description is reasonably adequate. However, the absence of any parameter semantics and the lack of explicit alternative tool routing leaves some context gaps for an agent to infer.

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

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

Schema description coverage is 0%, and the description offers no explanation of what 'cluster' or 'namespace' mean or how they affect the listing. The parameter names and titles provide minimal hints, but the description does not compensate for the missing schema documentation.

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

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

The description uses a specific verb and resource: 'List Secret metadata only'. It clearly distinguishes the tool from read/retrieve operations by stating 'secret values are never returned', which is crucial because this tool is not a full secret getter.

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 conveys a clear use case: retrieving only metadata about Secrets without exposing values. It implicitly tells the agent not to use this tool when Secret contents are needed, though it does not explicitly name an alternative 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 readOnlyHint=true and openWorldHint=false, so the description does not need to repeat safety. It adds a small behavioral detail, replica readiness, but says nothing about auth expectations, namespace semantics, or pagination. 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 concise sentence with no wasted words. It front-loads the core purpose, though it might have used a bit more room to clarify namespace scoping.

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 listing tool with an output schema and annotations, the description is minimally viable. The main gap is the lack of explicit namespace behavior and absent guidance on when to use this versus the more generic list_resources.

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 should compensate. The parameter names cluster and namespace are self-explanatory, but the description does not clarify what namespace=null means, whether only the given namespace is used, or any constraints on the cluster parameter.

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

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

States a specific verb and resource: 'List StatefulSets', and adds the output nuance 'replica readiness'. This clearly distinguishes it from sibling tools like list_pods or list_deployments, even without explicit comparison.

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

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

Usage is implied by the resource name: if an agent needs StatefulSets, this is the tool. However, it does not explicitly state when to prefer it over list_resources or provide any when-not/alternatives 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?

The readOnlyHint annotation already communicates that this is a safe read operation, so the description does not need to restate that. It adds the set of storage resources included, but provides no further behavioral details, such as whether namespace filtering applies only to PVCs or how cluster-scoped PVs and StorageClasses are handled.

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

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

One concise, front-loaded sentence with a clear verb and explicit object list. Every word earns its place and there is no repetition of schema or annotation 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?

Although the tool is simple and has an output schema, the complete lack of parameter semantics and absence of usage guidance means the agent cannot confidently determine the right values or know when this tool is preferred over generic alternatives. The description is not complete enough for correct invocation in an ambiguous 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 0%, and the description gives no explanation of what 'cluster' and 'namespace' mean, what values they accept, or how namespace interacts with cluster-scoped storage resources. The agent must rely solely on parameter names, which is insufficient for 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 clearly states a specific action ('List') and enumerates the exact resource kinds it handles: PersistentVolumeClaims, PersistentVolumes, and StorageClasses. This makes it readily distinguishable from siblings like list_pods or list_resources without needing to inspect schemas.

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

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

The description offers no guidance on when to prefer this tool over alternatives such as list_resources or get_resource, nor does it mention any selection criteria or prerequisites like cluster context. The agent is left to infer usage from the resource names alone.

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