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

Annotations already declare this as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds meaningful scoping behavior by explaining the namespace can target one namespace or all namespaces, but it does not disclose any further behavioral details such as field_selector filtering, event ordering, 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 focused sentence that leads with the action and resource, then covers the main scoping option. It contains no filler and earns its place.

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

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

For a simple read-only tool with two optional parameters and no output schema, the description covers the core purpose and namespace behavior. However, it omits critical semantics for field_selector and says nothing about what the returned events contain or any limits. It is minimally viable but leaves notable gaps for an agent.

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 explaining parameters. It partially explains namespace via 'specific namespace or all namespaces', but field_selector is left entirely unexplained. Since the schema only provides the name and type, an agent gets insufficient guidance on one of the two parameters.

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

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

The description states a specific verb and resource: 'Get Kubernetes events from the cluster.' It also specifies the scoping options ('specific namespace or all namespaces'), which clearly distinguishes it from sibling tools focused on pods, logs, deployments, and other resources.

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

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

The description tells what the tool does but provides no guidance on when to choose it over sibling tools like get_logs, list_pods, or get_resource. There is no mention of alternatives, exclusions, or prerequisite context, so an agent is left to infer when events are the right 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that logs can come from multiple resource types or label-selected resources, but it does not explain behavior such as whether a name or label_selector is required, how tail/default limits work, or what output to expect. This adds modest context beyond annotations but leaves several behavioral questions unanswered.

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 compact sentence with no filler words, and the key action is front-loaded. It conveys the core scope efficiently while leaving necessary details to other dimensions.

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

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

For a tool with 8 parameters, one required parameter, no output schema, and no parameter descriptions, a single sentence is incomplete. It does not specify valid resource_type values, the relationship between name and label_selector, default namespace behavior, or the response format. Annotations cover read-only/idempotent safety but not the operational details needed for correct invocation.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining parameters. It only clarifies label_selector and implies resource_type values (pods, deployments, jobs); it does not explain name, tail, container, namespace, timestamps, or since_seconds. Parameter names are self-descriptive, but the description fails to compensate for the absent 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 ('Get') and a clear resource scope: logs from pods, deployments, jobs, or resources matched by label selector. It is not a tautology, and the mention of multiple resource types distinguishes it somewhat from the sibling get_pod_logs, though it does not explicitly name that alternative.

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

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

There is no guidance about when to choose get_logs over get_pod_logs or other list/get siblings. The description only states what the tool does, not when to use it or when not to use it, so an agent must infer the intended context.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the scoping detail that it fetches pod logs in a namespace, but does not disclose return format, tailing behavior, or handling of missing pods. With annotations carrying the safety burden, 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 with no filler or redundancy. It wastes no words and immediately communicates the core action.

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 five parameters, zero schema description coverage, and no output schema, this description is too thin to fully support correct invocation. It lacks optional-parameter semantics, usage context, and any distinction from sibling log-related tools.

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 only clarifies 'pod' and 'namespace.' The optional parameters 'previous,' 'container,' and 'tail_lines' remain unexplained, leaving the agent to infer their meaning from names alone.

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

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

The description states a clear verb-resource pair: 'Get logs from a pod in a specified namespace.' It correctly describes what the tool operates on, but it does not distinguish this from the sibling 'get_logs' tool, so an agent cannot tell exactly when to choose this one versus that one without opening 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?

There is no guidance on when to use this tool versus alternatives like 'get_logs' or 'get_events.' It does not mention exclusions, prerequisites, or conditions that would make it the correct choice, leaving usage entirely 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. The description adds useful behavioral context beyond annotations by explicitly stating 'GET only; never mutates' and revealing that 'Blocked kinds are refused.' This gives the agent a clearer safety and failure 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?

Three short sentences with no filler. The core purpose is front-loaded, and each additional sentence ('GET only', 'Blocked kinds are refused') adds meaningful operational context.

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

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

The description is adequate for a simple read-only getter, but gaps remain: it does not describe return values, provide any list or explanation of blocked kinds, or clarify how api_version and namespace are used. Since there is no output schema, some of this burden falls on the description.

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

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

Schema description coverage is 0%, so the description must compensate for documenting parameters. It mentions 'by name' and 'any kind', which loosely maps to the name and kind parameters, but it does not explain namespace or api_version semantics or their defaults. This is a significant gap for a generic dynamic-client tool.

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 ('Get a single resource'), the resource scope ('any kind including CRDs'), and the mechanism ('by name via the dynamic client'). This distinguishes it from sibling list/get-log tools without needing to inspect their schemas.

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

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

The description makes the use case clear: retrieve one known resource by name as opposed to listing resources or fetching logs. It does not explicitly name alternatives or provide when-not-to-use conditions, but its context is specific enough to route an agent correctly.

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

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

Annotations already mark it readOnly, idempotent, and non-destructive; the description adds value by noting results are limited to kinds that 'can be listed', that CRDs are included, and that 'blocked kinds are omitted.' This provides behavioral filtering 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?

Two short sentences front-load the action and scope. 'Read-only discovery; blocked kinds are omitted' adds safety and filtering context in six words, with no filler.

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

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

For a no-argument, read-only discovery tool with no output schema, the description conveys what the result contains (listable resource kinds, including CRDs) and its filtering behavior. An agent selecting or invoking this tool is not missing critical information.

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 zero parameters and 100% coverage, so no parameter documentation is needed. The description correctly implies this is a parameterless discovery call without adding unnecessary detail.

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

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

The description opens with a specific verb, 'Discover', and names the resource: 'resource kinds (including CRDs) the cluster exposes and can be listed.' This clearly scopes it to capability discovery rather than instance listing, distinguishing it from sibling tools like list_pods and list_deployments.

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 'Discover which resource kinds...' identifies the tool for discovery use, and 'Read-only discovery' signals it is an exploratory step. However, it does not explicitly name when to prefer it over list_resource or state exclusions, so the guidance is clear but not exhaustive.

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

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

Annotations already provide the key behavioral safety profile: readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds the namespace scoping but does not disclose additional behavioral details like pagination, return format, or semantics of an omitted namespace. This is acceptable but not additive beyond what annotations already establish.

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. It states the action and scope immediately and every word earns its place, making it highly concise for a one-parameter tool.

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

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

For a simple read-only list tool with annotations covering safety, the description is mostly adequate. However, with no output schema and no explanation of the namespace default (null), an agent cannot fully determine the behavior when no namespace is supplied, leaving a meaningful completeness gap.

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

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

Schema description coverage is 0%, so the description must compensate for the namespace parameter, but it does not explain the nullable default or what happens when namespace is omitted. The parameter name is self-explanatory, but the description only says 'specified namespace,' which actually implies the parameter is required when the schema marks it optional.

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 all deployments in a specified namespace.' It clearly names the resource (deployments), the action (list), and the scope (namespace), making it immediately distinguishable from siblings like list_pods and list_services.

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

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

The description implies when to use the tool: whenever deployments in a namespace need to be listed. It does not explicitly mention alternatives or exclusions, such as using list_resource for a generic resource lookup, so guidance is only 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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the allowlist filtering behavior, which is not present in the annotations. No return-format detail is given, but for a parameterless read-only list operation this is a minor 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 efficient sentence that front-loads the action and resource, then adds the only relevant qualifier. There is no redundant wording or repetition of the title.

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 operation with no output schema, the description is complete. It states what is listed, the cluster scope, and the allowlist filter. Nothing else is needed for an agent to invoke the tool correctly.

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

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

The tool has zero parameters and the schema is empty with 100% schema description coverage. Per the rubric, a baseline of 4 applies because there are no parameters for the description to clarify.

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 all namespaces in the cluster', and adds a scope qualifier ('filtered by the namespace allowlist'). This clearly distinguishes it from sibling tools like list_pods, list_deployments, and list_nodes because it names the exact resource being listed.

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

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

The description provides clear context: use this tool to enumerate all allowed namespaces in the cluster. It does not explicitly name alternatives or exclusion conditions, but the scope is unambiguous and the constraint about the allowlist helps an agent understand when this tool is 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 already declare readOnlyHint=true and idempotentHint=true. The description adds the scope 'in the cluster', clarifying the operation is on the entire cluster. No additional behavioral traits beyond what annotations provide are needed for such a simple tool.

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

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

Single sentence (7 words) with no unnecessary information. Front-loaded with the key 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 is complete for a simple list tool with comprehensive annotations. It lacks details about the output format, but given the tool's simplicity and standard behavior, this is acceptable.

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?

There are no parameters, so the description doesn't need to add parameter information. Schema coverage is 100%, and baseline for zero params is 4.

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

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

The description clearly states the action (list), resource (nodes), and scope (in the cluster). It distinguishes from sibling tools like list_pods by specifying the 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 guidance on when to use this tool vs alternatives. For example, it doesn't mention that get_resource should be used for listing individual nodes, or that this tool returns all nodes without filtering.

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, covering the safety profile. The description adds the namespace-scoping behavior, including the all-namespaces option, but does not disclose return format, pagination, or ordering. There is 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?

One sentence, front-loaded with the verb and resource, with no filler or repetition of the title. Every word contributes to the tool's meaning.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description plus annotations are sufficient for correct invocation. It does not describe the returned data shape, but the annotations and low schema complexity make that a minor gap rather than a blocking omission.

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 explains the only parameter's effect by noting pods can be listed 'in a namespace or across all namespaces', which maps directly to the optional namespace parameter. It does not spell out the default behavior in schema terms, but the meaning is still clear.

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 and resource ('List all pods') and clearly scopes the behavior to a namespace or all namespaces. It is immediately distinguishable from sibling tools like list_deployments and list_services by naming the pod resource explicitly.

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 namespace/all-namespaces context gives clear invocation context, but there is no explicit guidance about when to use this tool versus alternatives such as list_resource or list_deployments. Usage must be inferred from the tool name and description rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description's 'never mutates' mostly reinforces them. It adds valuable non-obvious behavior: blocked kinds listed in config.toml are refused, and the dynamic-client mechanism is disclosed. 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?

Three terse sentences, each earning its place: the first states the action and scope, the second guarantees no mutation, and the third warns about blocked kinds. The most decision-relevant information is front-loaded.

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

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

For a generic read-only list tool, the description covers core purpose, safety, and the blocked-kind failure mode. However, there is no output schema, no mention of return shape or pagination, and no guidance on selector syntax or setting api_version for CRDs, leaving moderate 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 description must compensate for the five parameters, but it only indirectly supports 'kind' via 'any kind'. Nothing explains api_version, namespace, field_selector, or label_selector semantics, leaving the agent to infer meaning from parameter names alone.

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

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

The description states a specific verb ('List'), a resource scope ('resources of any kind including CRDs'), and the mechanism ('dynamic client'), making it clearly distinct from specialized siblings like list_pods and list_deployments. The GET/LIST-only qualifier further pins down 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 implies when to use it: any resource kind, including CRDs, that sibling list tools do not cover. However, it does not explicitly name alternatives or state when not to use it, and 'Blocked kinds are refused' is the only direct usage constraint.

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 covered. The description adds the namespace-scoping behavior, but it does not disclose pagination, sorting, RBAC requirements, or list size limits.

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 crisp sentence with no filler; the core scoping information is front-loaded.

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

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

For a simple read-only list tool with a single optional parameter and annotations covering side effects, this description is nearly sufficient. It lacks an explicit mention of return shape or pagination, but the function's purpose is fully stated.

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 zero description coverage, so the description carries the parameter burden. 'In a namespace or across all namespaces' clarifies that namespace is optional and that omitting it means all namespaces, which is the key semantic 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 names the specific verb ('List') and resource ('services') and precisely defines the scope as 'in a namespace or across all namespaces'. This makes it easy to distinguish from sibling tools like list_pods and list_deployments.

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: whenever services need to be enumerated, with optional namespace scoping. However, it never names alternatives such as list_resource or states 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.