k8s-mcp-server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have clearly distinct purposes, but there is some overlap between cluster info, health checks, and resource usage, as well as between cluster config management (import_cluster, list_clusters) and kubeconfig file management (load_kubeconfig, get_kubeconfig_info). The batch_* family is clearly differentiated by action, but the cluster vs kubeconfig distinction could confuse an agent.
Naming Consistency4/5
Tool names generally follow a verb_noun snake_case pattern (e.g., get_pod_logs, batch_delete_resources, manage_node), which is predictable. There are minor deviations: verbs vary among get/list/check/backup, and the batch_* prefix forms a sub-pattern that is consistent within itself but not uniform across the whole set.
Tool Count2/5
With 32 tools, the server feels overloaded. Many batch_* operations could be consolidated into a single parameterized batch tool, and the multiple health-check and kubeconfig management tools are redundant. The scope is broad, but 32 tools exceed a manageable size for an agent to choose from effectively.
Completeness4/5
The tool set covers a comprehensive range of Kubernetes operations: resource CRUD via batch_* tools, pod logs/exec/copy/port-forward, health checks, node management, backup/restore, and cluster configuration. Minor gaps exist such as a direct apply/scale function or a single-resource get, but the batch tools can handle most workflows.
Average 3.6/5 across 28 of 32 tools scored. Lowest: 1.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 1 commit in the last 12 weeks
- Last stable release on July 20, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and no output schema, the description carries the full burden of explaining side effects. It fails to disclose what setting a default cluster means, whether it affects future operations, persists, or requires special permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, but this is under-specification rather than effective conciseness. The Args/Returns sections are terse yet uninformative, adding little value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Even for a simple one-parameter tool, the description is incomplete. It does not explain the purpose of a 'default cluster', how the setting is used, or what a successful return looks like, leaving the agent with a tautological overview.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema's 'name' parameter has 0% description coverage, and the description only adds '集群名称' (cluster name), which adds essentially no semantic value beyond the parameter name itself. The description does not compensate for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '设置默认集群' is a direct translation of the tool name 'set_default_cluster', restating it without adding any specificity. It does not distinguish this tool from siblings beyond what the name already implies.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 import_cluster or list_clusters. There is no mention of prerequisites, context, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for behavioral disclosure. It says 'delete' which implies destructive action, but it does not explain consequences, reversibility, required permissions, or effects on cluster connections. The 'Returns: 删除结果' is vague and does not clarify outcome details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and structured with Args/Returns sections. It is efficient and contains no fluff. For such a simple tool, the size is appropriate, though it may be under-specified. It earns a high score for conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description should compensate by explaining return values and side effects. It only says '删除结果' (deletion result), which is unhelpful. Also missing are potential errors, whether deletion is permanent, and what 'name' refers to in practice. The description is incomplete for a destructive operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has one required parameter 'name' with no description, and schema coverage is 0%. The description adds 'Args: name: 配置名称' which translates to 'configuration name', providing a minimal clarification. However, this only restates the parameter's existing title and does not explain what kind of name, format, or examples are expected.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states '删除kubeconfig文件' which clearly indicates deleting a kubeconfig file. However, it is very close to the tool name and does not add scope or differentiation from related operations like load_kubeconfig or list_kubeconfigs. It is a clear verb+resource statement but lacks sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There is no mention of prerequisites, side effects, or conditions under which deletion is appropriate. The description only states the action and arguments, offering no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It mentions 'include_secrets' defaults to True, which implies secrets are backed up by default, and explains kubeconfig fallback logic. However, it does not state whether the operation is read-only, where the backup is stored, whether it overwrites existing backups, or what permissions are required. This significant gap is particularly concerning for a backup operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a compact parameter list with a one-line purpose prefix. It is free of filler and gets straight to the point, making it easy to scan. The structure is consistent and each parameter is given a brief explanation. It loses a point for not using a more standard prose format that could have integrated usage context more smoothly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description must explain the tool's full behavior, but it only covers parameter semantics. It fails to describe what a backup actually produces, how it is stored, how to restore it, or what the expected side effects are. For a 4-parameter operation on a Kubernetes namespace, this is incomplete and leaves many critical questions unanswered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The overall schema has 0% description coverage, so the description is the only source of parameter meaning. It provides useful semantics for 'include_secrets' (whether Secret resources are included, default True) and 'kubeconfig_path' (fallback to cluster_name or default cluster if not set). However, 'namespace' and 'cluster_name' are nearly tautological ('命名空间名称', '集群名称（可选）') and add little beyond the property names. Overall, it compensates partially for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with '备份命名空间' (backup namespace), which directly restates the tool name and gives a verb+resource. However, it never explains what the backup entails (e.g., snapshot, export YAML, archive), nor does it distinguish this tool from the sibling 'backup_resource' or 'restore_from_backup'. The scope is implied by the name but not stated explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. The description only lists parameters and their defaults. It does not mention when a namespace-level backup is appropriate, when to prefer 'backup_resource' for individual resources, or any prerequisites such as cluster connectivity. This leaves the agent to infer usage solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain side effects, idempotency, atomicity, error behavior, or what happens to existing resources. The only behavioral trait mentioned is the kubeconfig fallback logic, which is insufficient for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured, with a single-sentence summary followed by parameter details. There is no filler or redundant information. Each line serves a purpose, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
As a mutation tool with no annotations and no output schema, this description is incomplete. It omits return values, error handling, resource type support, and how updates are applied. The parameter documentation is helpful, but the operational context is largely absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context to the parameters. It clarifies that 'resources' is a JSON-formatted list, and it explains the fallback relationship between kubeconfig_path and cluster_name. With schema description coverage at 0%, this significantly compensates for the bare schema. The namespace explanation is minimal, but overall it adds value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states '批量更新资源' (batch update resources), which is a clear verb+resource combination. However, it is essentially a restatement of the tool name and lacks detail on what 'update' entails (e.g., patch vs replace). It only minimally distinguishes from sibling batch tools like batch_create or batch_delete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 batch_create or batch_delete. No prerequisites, exclusions, or contextual scenarios are provided. The parameter list offers fallback logic but no usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries full responsibility. It mentions 'delete' but does not disclose side effects, reversibility, permission requirements, or whether this affects the live cluster or just its configuration. The distinction between 'delete cluster' and 'delete cluster configuration' is ambiguous, and no safety hints are provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured, with an action line, explicit Args and Returns sections. Every word serves a purpose, and the format is easy to parse. It is not verbose or redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the tool's simplicity, the description lacks essential context for a destructive operation. There is no output schema, and the return value is only '删除结果' (deletion result) without details. It fails to clarify the scope of deletion, making it incomplete for an agent to safely invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description compensates minimally by stating that 'name' is the cluster name. This adds semantic meaning beyond the bare property name, but it does not provide format constraints, examples, or how to obtain the name. For a single required parameter, it is adequate but not rich.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('删除集群配置' = delete cluster configuration) with a clear verb and resource. It distinguishes from siblings by focusing on cluster deletion rather than listing, importing, or getting info, though it does not explicitly differentiate from delete_kubeconfig or batch_delete_resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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. There is no mention of prerequisites, whether to prefer this over delete_kubeconfig for specific cases, or any context for when deletion is appropriate. The usage is only implied by the verb 'delete'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'restore from backup' with no mention of the operation's side effects (e.g., overwriting existing resources, needing cluster permissions, whether it is destructive) or any other traits. This is effectively no disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-structured: a one-line summary followed by a clear Args list. Every line provides useful information without redundancy, and the front-loaded purpose makes the tool's intent immediately clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, yet the description only covers the purpose and parameter meanings. It omits behavioral details like what happens during restore, whether it replaces existing resources, what errors might occur, and what the success/result indication is. Given the complexity of a restore operation, this is incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% because the schema properties have no descriptions. The description compensates with an Args block that explains each parameter: backup_file path, optional target_namespace, optional target_cluster, and kubeconfig_path with fallback to default cluster. This adds meaningful context beyond the schema's type/default info, though it could be more detailed about expected value formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Restore resources from backup' with a clear verb-object structure. It is distinct from the backup creation tools in the sibling list, though it could be more specific about what types of resources or what form the backup takes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided about when to use this tool versus alternatives. The existence of backup_namespace and backup_resource implies restore is the counterpart, but the description does not state prerequisites, exclusions, or when an alternative like backup_resource or list_backups might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full responsibility for behavioral disclosure. It hints at Kubernetes deletion semantics via 'grace_period_seconds' (优雅删除等待时间) and explains cluster selection logic, but it does not state that deletion is destructive, irreversible, or what permissions are required. This is a critical gap for a batch delete operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a compact docstring: a one-line purpose followed by a parameter list. It is front-loaded with the action and each parameter gets a short, useful explanation. No filler or redundant text, making it easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This destructive tool has no annotations and no output schema. The description only covers parameter syntax and omits important context such as return values, error handling, safety warnings, and behavioral impact. For a batch delete operation with five parameters, this is insufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Despite 0% schema coverage, the description adds meaningful explanations for all five parameters. For example, 'resources' is described as a JSON-format resource list, and the interplay between kubeconfig_path and cluster_name is clarified ('不指定则使用 cluster_name 或默认集群'). This goes beyond the schema titles, though details like the exact format of the resource list remain vague.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '批量删除资源' (batch delete resources) clearly identifies the action (delete) and target (resources). The parameter list with 'resources', 'namespace', and 'grace_period_seconds' distinguishes it from sibling batch operations. However, it doesn't specify exactly which resource types are supported, leaving a minor ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 batch_update_resources or batch_create_resources. No prerequisites, exclusions, or alternative recommendations are provided. The description only lists parameters without context on use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full behavioral disclosure burden. It explains parameter precedence (kubeconfig_path vs cluster_name) and resource_types formats, but it fails to disclose return value structure, pagination, error handling, permission requirements, or whether the operation is read-only. The Returns line '批量查看结果' is tautological and adds no behavioral insight.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a one-sentence summary followed by Args/Returns sections. The resource_types explanation is detailed but necessary given the parameter's complexity. However, the Returns line is vague and could be replaced with concrete output details, slightly reducing value per sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description leaves critical gaps: the return value is unspecified beyond 'batch view results', and there is no mention of pagination, errors, or permissions. While parameter semantics are solid, the overall behavioral contract is under-specified, making the description sufficient only as a minimal functional overview.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is the only source of parameter semantics. It thoroughly explains resource_types with three supported formats and CRD support, and clarifies the relationship and precedence between kubeconfig_path and cluster_name. namespace is only labeled, but its meaning is obvious. This significantly compensates for the missing schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description '批量查看资源' clearly indicates a batch listing operation, and the tool name 'batch_list_resources' reinforces this. It is distinguishable from sibling batch_create/update/delete tools by the verb 'list/view', but it does not explicitly differentiate from batch_describe_resources or other read-only tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions or reference sibling tools like batch_describe_resources for detailed descriptions. The only implied usage is the bare phrase 'batch view resources', which is insufficient for selecting among the many batch_* and read-oriented tools in the cluster.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must explain behavioral traits. It only says 'batch restart results' without detailing what a restart entails (e.g., rolling restart, pod deletion, readiness checks), potential side effects, or required permissions. This is a significant gap for a mutating operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with a clear heading, Args, and Returns sections. It is reasonably concise and all listed parameter explanations are useful, though the Returns line is somewhat vague and could be omitted or expanded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While parameter details are well covered, the tool description lacks behavioral context, output details, and usage scenarios. For a batch mutation tool with no annotations or output schema, the description should disclose more about the restart mechanism and potential impact to be complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage and resources is just a string, but the description compensates well by explaining the JSON format with a concrete example, the namespace default, and the precedence between kubeconfig_path and cluster_name. This goes beyond the schema and adds critical usage detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '批量重启资源' (batch restart resources), identifying the action and target resource type. It provides the expected input format and parameters, but does not explicitly distinguish itself from sibling tools like batch_rollout_resources, which may also handle restarts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide any guidance on when to use this tool versus alternatives such as batch_rollout_resources or batch_delete_resources. It merely lists arguments without explaining the intended use case or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It explains parameter selection behavior (kubeconfig_path vs cluster_name) but does not state whether the operation is read-only, what exact information is returned, or potential side effects. The return value '集群信息' (cluster info) is vague.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with a clear summary, followed by structured Args and Returns sections. It is appropriately sized for a simple tool, with no wasted sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with 2 optional parameters and no output schema. The description covers the parameter selection logic but does not specify return fields or error conditions. It is minimally adequate but lacks detail to fully understand the tool's output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, yet the description compensates by explaining each parameter's semantics: kubeconfig_path is the config file path, and cluster_name is used when kubeconfig_path is not specified. This adds meaning beyond the schema's type/default information, though could be more detailed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '获取Kubernetes集群信息' (Get Kubernetes cluster info), which is a specific verb+resource pair. However, it does not distinguish this from sibling tools like get_cluster_resource_usage or check_cluster_health, which also relate to cluster information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It only explains the parameters, not the intended use case or scenario. There is no mention of when to prefer get_cluster_info over other cluster tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the sensitive nature of the kubeconfig content and explains the mask_sensitive parameter behavior, which is helpful. However, it does not disclose other behavioral traits such as where the config is loaded from or potential errors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and well-organized, with a warning note, argument explanations, and return value. Every sentence serves a purpose, and the structure is clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool, the description covers the main action, return value, and a critical safety note. However, it lacks details about output format (e.g., YAML/JSON) and error conditions, leaving some context missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema provides only bare titles ('Name', 'Mask Sensitive'), and schema description coverage is 0%. The description compensates by explaining 'name' as configuration name and 'mask_sensitive' as masking token/certificate fields, adding real semantic value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool loads a kubeconfig file and specifies it returns the file content. It clearly identifies the action and resource, but does not explicitly differentiate from sibling tools like get_kubeconfig_info or list_kubeconfigs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions or prerequisites, making it unclear when to choose load_kubeconfig over list_kubeconfigs or get_kubeconfig_info.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavioral traits. It mentions that omitting node_name checks all nodes and describes kubeconfig fallback logic, but it does not disclose whether the operation is read-only, if it requires special permissions, or what the health report contains. This is minimal transparency for a tool that could potentially affect cluster state or take time.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with Args and Returns sections, and each parameter explanation is concise. It is not overly verbose, though it could be tightened by removing the REST-style parameter block since the schema already lists the fields, but the extra details are useful given the lack of schema descriptions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a health-check tool with no output schema and no annotations, the description covers the action, parameters, and return type. However, it lacks details on the format of the health report, any prerequisites, and potential side effects, leaving some gaps for an agent to fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the description compensates by explaining all three parameters: node_name, kubeconfig_path, and cluster_name, including their default behaviors and fallback relationships. This adds significant meaning beyond the bare schema fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '检查节点健康状态' (check node health status), which is a specific verb+resource combination. It distinguishes itself from sibling tools like check_cluster_health and check_pod_health by focusing on nodes, and the title of the tool matches the action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as check_cluster_health or check_pod_health. It does not mention any exclusions or preferred contexts, leaving the agent to infer usage solely from the tool name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It does mention that the server validates cert-key match and returns error with curl upload instructions, which is useful. However, it does not disclose whether importing overwrites an existing cluster, what permissions are required, whether the operation is reversible, or what the actual return payload contains. This is a significant gap for a state-changing tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized with a short summary, a clear numbered list for kubeconfig forms, an Args section, and a Returns line. It is appropriately sized, though the phrase '见下方' (see below) is slightly confusing as the upload guidance appears in the error message section, not literally below.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks guidance on when to use this tool vs load_kubeconfig, what happens on overwrite, required access levels, and a meaningful return description. The kubeconfig parameter is well covered, but overall operational context is insufficient for an agent to use this tool safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description fully compensates by explaining every argument: name character constraints, kubeconfig three accepted forms with context, and defaults for service_account, namespace, and is_default. This goes well beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '导入集群配置' (Import cluster configuration), using a specific verb and resource. It is distinct from sibling tools like list/delete clusters, though it does not explicitly differentiate from load_kubeconfig. The return value '导入结果' is vague, slightly weakening purpose clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides detailed guidance on how to specify the kubeconfig parameter, including three accepted forms and when a local file needs to be uploaded. However, it does not explicitly state when to use this tool versus alternatives such as load_kubeconfig, nor does it mention any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so the description carries the transparency burden. It discloses the rollback_on_failure behavior and the priority between kubeconfig_path and cluster_name. However, it does not mention idempotency, error handling side effects, or whether the operation is atomic beyond the rollback option. These are notable gaps for a batch mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a compact, front-loaded docstring with a one-line summary followed by a bulleted parameter list. Every line adds value, and the formatting is easy to scan. No redundancy or filler exists.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should explain what the tool returns or how success/failure is reported. It does not. It also lacks error condition descriptions, making it incomplete for a batch operation that could partially fail. The rollback parameter hints at failure semantics but does not describe the final state feedback.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, so parameter explanations in the description are critical. It adds meaning for all five parameters: defines resources as a JSON list with kind, metadata, spec; explains rollback_on_failure; and clarifies the precedence between kubeconfig_path and cluster_name. This fully compensates for the barren schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description begins with '批量创建资源' which clearly states a batch create operation for resources. This distinguishes it from sibling tools like batch_update_resources and batch_delete_resources based on the verb. However, it lacks detail on the scope or method of creation, so it does not fully elaborate the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as batch_update_resources or individual create tools. It does not mention prerequisites like cluster connectivity, nor does it specify whether it should be used for initial creation only. The parameter list implies usage but gives no explicit context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries full responsibility. It only states the basic listing action and that a list is returned, but does not disclose read-only nature, potential errors, requirements, or any side effects. The behavior is implied by 'list' but not explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a single action sentence, but the 'Returns' line 'kubeconfig文件列表' is redundant with the first sentence, slightly reducing efficiency. Still, it is front-loaded and appropriately sized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no parameters and no output schema, the description is adequate. It specifies the resource scope ('all saved kubeconfig files') and return type, but could mention where the files are located or how they are referenced, though that is likely domain knowledge.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the input schema is empty, so schema coverage is trivially 100%. The baseline for 0 parameters is 4, and the description adds no parameter-related meaning because there are none to describe.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists all saved kubeconfig files, using a specific verb ('列出') and resource ('kubeconfig文件'). It distinguishes from siblings like load/delete/get_kubeconfig_info by focusing on listing all, not individual operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 load_kubeconfig or get_kubeconfig_info. The description simply states what it does without any contextual hints or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states it retrieves detailed info, which implies read-only, but does not explicitly mention that it does not modify resources, what permissions are required, how errors are handled, or what happens if a resource is not found. Beyond the inherent 'get' semantics, it adds little about behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description uses a clear structured format (summary, Args, Returns). The parameter explanations are concise and the format example is warranted. It is slightly longer than strictly necessary but every sentence contributes to understanding. The summary is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description should explain the return format more precisely. It only says '批量资源详细信息' (batch resource detailed info) without describing structure, pagination, or error behavior. Also, no guidance on cluster selection when both kubeconfig_path and cluster_name are absent, or about cluster_name needing clusters.json. Overall, the completeness is insufficient for a moderately complex batch tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description's Args section significantly explains each parameter. It provides a concrete format example for resource_specs, explains the relationship between kubeconfig_path and cluster_name, and clarifies the meaning of namespace. Since the schema has no property descriptions (0% coverage), this description fully compensates and adds substantial meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '批量获取资源详细信息' (batch get resource detailed information), with the verb '获取' (get) and resource '资源' (resources). This distinguishes it from sibling tools like batch_list_resources, batch_create_resources, etc., which are explicitly named for different operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides conditional usage context: kubeconfig_path is used if specified, otherwise cluster_name or the default cluster is used. However, it does not explicitly say when to choose this tool over alternatives like batch_list_resources or get_cluster_info. The batch prefix implies usage for multi-resource operations, but no exclusions or alternatives are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses one meaningful behavioral trait: pod_resources exceeding 50 entries will be truncated, returning truncated and total_count. However, it omits other behavioral details such as whether the operation requires special permissions, what happens on error, or whether it is strictly read-only beyond the 'get' connotation. There is no contradiction with annotations (none provided).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured with clear Args and Returns sections. Every line earns its place, providing essential parameter explanations and return behavior without redundancy. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and no annotations, the description explains the return report and truncation behavior, which is helpful. It also fully documents parameters. However, it does not describe what the resource usage report includes (e.g., CPU, memory, pod-level metrics) or outline the report structure. Still, for a straightforward read-only tool with optional params, the provided context is largely sufficient for an agent to invoke and interpret basic results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero description coverage, but the description compensates thoroughly. It explains each parameter: namespace meaning and default, kubeconfig_path precedence, and cluster_name usage when kubeconfig_path is omitted. It also clarifies the relationship between cluster_name and kubeconfig_path, adding significant meaning beyond the schema's bare titles and defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states '获取集群资源使用情况' (get cluster resource usage), specifying a specific verb and resource. It distinguishes from most siblings like get_pod_logs and get_cluster_info, but does not explicitly differentiate from batch_top_resources, which might also list resource usage. Therefore it lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, nor any prerequisites or conditions. The description only explains parameters and return behavior, not usage context. It neither states exclusions nor alternative tool references.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry full behavioral disclosure. It only states the action and lists parameters, but does not disclose what the backup operation produces, where it stores backups, whether it is destructive, what errors may occur, or any permission requirements. This is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with a clear purpose statement, and uses a clean list format for parameters. It wastes no words, though it repeats parameter names that also appear in the schema; the additional Chinese explanations justify their presence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderately simple, but the description lacks information about output format, error handling, or relationship to the sibling backup_namespace tool. With no output schema or annotations, the description should explain more about the backup's result and behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no descriptions for parameters, so the description's Args section provides essential semantics—resource_type lists examples, kubeconfig_path explains fallback behavior, and cluster_name is noted as optional. This adds substantial meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool backs up specific resources (备份特定资源), with the verb 'backup' and resource type parameters. It distinguishes from sibling backup_namespace by explicitly focusing on individual resources rather than whole namespaces.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by listing the resource types (deployment, service, configmap) and the optional cluster parameters. It clearly implies this is for backing up a specific resource, distinct from namespace-level backup, though it does not explicitly name the alternative tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it executes a command and returns the result, but does not mention potential side effects (e.g., command may modify the pod or cluster), permission requirements, interactivity, or any safety caveats. This is a significant gap for an arbitrary command execution tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with labeled sections (Args, Returns) and each parameter is on its own line. It is appropriately sized for the tool's complexity, though a few elements (like repeating the parameter names in the schema) are redundant. No unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers all six parameters, including defaults and optionality, and states that the return value is the command execution result. It does not detail error handling, output format, or edge cases (e.g., what happens if the pod has multiple containers and none is specified), but the core information needed to invoke the tool is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides detailed semantics for every parameter, including an example for 'command' (e.g., ["ls", "-la"]), defaults for 'namespace' (default) and 'container' (must specify if multi-container), and the interaction between 'kubeconfig_path' and 'cluster_name'. This fully compensates for the 0% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: to execute a command inside a Kubernetes Pod ('在Pod中执行命令'). This uses a specific verb ('execute') and resource ('Pod'), distinguishing it from sibling tools like getting logs, copying files, or port-forwarding.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The usage context is implied by the purpose and the parameter list (e.g., namespace, container). However, there is no explicit statement about when to choose this tool over alternatives, nor any exclusions or preconditions. The tool's name and description make its primary use obvious, but no comparative guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the operation is read-only ('仅读取本地备份目录') and does not require K8s connection, which is key transparency for an agent. However, it does not detail filtering behavior or output format, so it is not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded: it starts with the core purpose, adds a critical behavioral note, then lists the args. Every sentence adds value and there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no annotations or output schema, and the description omits important contextual details such as how the optional parameters filter the backup listing and what the return format looks like. This makes the description insufficient for an agent to fully understand the tool's behavior in a real interaction.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
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. It only restates the parameter names (集群名称, 命名空间) and marks them optional, which the schema already indicates via defaults. It does not explain how cluster_name or namespace affect the backup listing, leaving the parameters semantically underspecified.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists backup files and adds the specific context that it only reads a local backup directory without requiring a K8s connection. This makes the tool's purpose unambiguous and distinguishes it from K8s-dependent sibling tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for use: it is for listing backups locally without K8s connectivity. However, it does not explicitly mention when not to use it or name alternative tools, so it falls just 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It explains parameter behavior (defaults, conditional applicability) and indicates the return type, but does not explicitly state whether the operation is read-only, requires specific permissions, or what constitutes a health check.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with purpose, Args, and Returns sections, each concise. The docstring format is slightly verbose but every sentence provides necessary detail without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers the essential context: purpose, parameters, and return value. With no annotations or output schema, it could be more detailed about the result structure and potential side effects, but is adequate for a health-check tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description compensates fully by explaining each parameter's purpose, default, and inter-dependencies (e.g., rbac_namespace only when include_rbac_check is True, kubeconfig_path vs cluster_name precedence).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states a specific action: check Kubernetes cluster health, optionally with RBAC conflict detection. This distinguishes it from sibling tools like check_node_health and check_pod_health by focusing on cluster-level and the unique RBAC feature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the purpose (check health), but no explicit guidance on when to use this over sibling health tools like check_node_health or check_pod_health, nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavior on its own. It provides useful details about the 'previous' flag for pre-restart logs, default line count, and kubeconfig/cluster_name fallback logic. However, it does not mention permission requirements, error behavior, or what happens when a multi-container pod lacks a specified container.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured: a one-line summary, a coherent Args list, and a Returns section. It is appropriately sized for a tool with 7 parameters and avoids redundant filler, earning every sentence's place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description should clarify return value and edge cases. It says only '包含Pod日志的结果' without specifying format or content. Parameter guidance is strong, but behavioral boundaries such as errors or multi-container requirements are incomplete, leaving the description adequate but not fully comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description's Args section thoroughly explains all 7 parameters, including defaults and special cases like container needed for multi-container pods. It also clarifies the precedence relationship between kubeconfig_path and cluster_name, which the schema does not convey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description begins with '获取Pod的日志', clearly stating the tool retrieves Pod logs. This specific verb+resource phrase unambiguously distinguishes it from sibling tools such as exec_pod_command or check_pod_health.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies its usage context—fetching pod logs—but does not explicitly state when to use it over alternatives, nor does it mention any exclusions or prerequisites. There is no 'when-not-to-use' guidance or reference to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden; it indicates a read-only 'view' operation and clarifies the list-vs-detail response based on the name parameter. It does not disclose potential permission requirements, error conditions, or response structure beyond what is stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded, but it repeats the conditional behavior in the main description and again in the Args section (e.g., '指定则返回该集群的配置详情' vs '指定则返回该集群详情'). Minor redundancy prevents a 5.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one optional parameter and no output schema, the description adequately covers behavior, parameters, and return type. It does not elaborate on pagination, authorization, or field details, but these are not expected for a basic list/detail operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description fully compensates by explaining the single name parameter: it is optional, omitting it lists all clusters, and specifying it returns cluster details. This adds critical meaning beyond the bare string/null schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb+resource ('查看集群配置') and specifies conditional behavior: omitting name lists all imported clusters, while specifying name returns cluster details. However, it does not explicitly differentiate from the sibling get_cluster_info, which may also return cluster details, so sibling distinction is incomplete.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives clear context on when to omit or specify the name parameter, effectively describing the two usage modes. It does not name alternatives or state when not to use this tool, so it falls short of explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does disclose key side effects like drain evicting pods and default behavior for DaemonSet and mirror pods. It lacks details on permissions, reversibility, or potential cluster-level impact, which is important for a mutating Kubernetes tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear header and parameter list, and every parameter earns its place. The Returns section is vague, but overall the text is efficient and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters and no output schema or annotations, the description covers all the essential parameter semantics and action behavior, making it usable. However, the return value is only described as '操作结果', and missing error/permission context leaves minor completeness gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates thoroughly by explaining all six parameters, including action enum values with kubectl equivalents and the precedence between kubeconfig_path and cluster_name. This adds substantial meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as node operations management with three explicit actions (drain, cordon, uncordon), mapping them to kubectl equivalents. This distinguishes it from sibling tools focused on checking health or general resource management.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The action definitions imply when each operation is appropriate, such as using drain to evict pods or cordon to mark unschedulable. However, it doesn't explicitly state when to prefer this tool over alternatives like check_node_health or batch_update_resources, nor does it provide exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It explains rollback behavior (without revision rolls back to previous, with revision rolls to that version), notes that pause/resume apply only to Deployments, and clarifies kubeconfig_path vs cluster_name precedence. This is good transparency, though it doesn't mention permissions or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with Args and Returns sections. Each sentence provides necessary information without repetition or fluff. It is appropriately sized for the complexity of the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 4 parameters, no output schema, and no annotations, the description covers all parameters and actions in sufficient detail. It lacks specification of the return result structure or error conditions, but the core usage is complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate. It thoroughly documents the operations parameter with its JSON structure, each action's semantics, and the revision field. It also explains namespace, kubeconfig_path, and cluster_name meanings. The only minor issue is that the schema types operations as a string, while the description shows it as a JSON array without clarifying how the string is encoded.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs batch rollout operations with specific actions: status, rollback, pause, and resume. It names the resource type (Deployment) and the exact operations, distinguishing it from sibling tools like batch_list_resources or batch_delete_resources. This meets the 'specific verb+resource' benchmark.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by listing actions and the operation format, but it does not explicitly state when to use this tool over alternatives or provide when-not-to-use guidance. For example, it doesn't compare with batch_update_resources or batch_restart_resources, 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the burden of disclosing behavior. It explains the two operational modes (reading a saved config vs validating content) but does not explicitly state that the tool is read-only, what happens on errors, or any permissions required. The verbs imply non-mutating behavior, but this is not made explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, starting with a summary sentence, then listing the two usage modes, the arguments, and the return value. Every sentence adds value and there is no unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description only vaguely states 'kubeconfig detailed information or validation result' without specifying the structure of the return value or error conditions. It adequately covers the two usage modes, but for a tool with no output schema, more detail on return format and failure handling would be expected.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description fully compensates by defining both parameters: 'name' as a saved configuration name for reading details, 'content' as kubeconfig file content for validation, and clearly stating they are mutually exclusive. This adds substantial meaning beyond the bare input schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves kubeconfig details or validates content format, using specific verbs ('获取' and '验证') and a resource ('kubeconfig'). It distinguishes two usage modes and differentiates from sibling tools like list/delete/load by focusing on info retrieval and validation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly lays out two usage contexts: passing a saved name to get details, or passing content to validate format, and notes the parameters are mutually exclusive. It does not mention alternative tools or exclusions, but provides clear context for how to use the tool itself.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the significant behavior of reloading kubeconfig from disk, but does not mention side effects, authentication requirements, or what happens on failure. This is partial transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise: a one-line purpose, an args section, and a returns section. Every sentence earns its place, and the structure is clear and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter test tool with no output schema, the description covers the essential purpose, behavior, argument, and return type. It does not elaborate on error cases, but given the simplicity and sibling context (e.g., check_cluster_health exists), it is reasonably complete and not under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Although the schema has no descriptions, the description explicitly lists 'name: 集群名称' (cluster name), providing meaning beyond the bare schema field. For a single parameter this is sufficient, but lacks deeper context like formats or defaults.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'test cluster connection' with a specific verb and resource, and adds the unique behavior of reloading kubeconfig from disk. This distinguishes it from siblings like check_cluster_health or get_cluster_info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage is for testing connectivity with fresh credentials by reloading kubeconfig. It gives clear context but does not explicitly name alternatives or exclusion criteria, earning a 4 rather than 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses key behavioral traits: the dependency on metrics-server ('依赖集群已部署 metrics-server'), the fallback logic for kubeconfig_path (if not specified, uses cluster_name or default cluster), and the namespace constraint ('仅对 pods 有效'). These add valuable context beyond the schema and imply a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a one-line summary followed by clearly labeled Args and Returns sections. Each sentence contributes necessary information without redundancy. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only metrics tool with no annotations or output schema, the description covers the essential aspects: purpose, all parameters, return data, and a critical dependency. It lacks details on return data structure or error handling, but these are less critical for this simple batch query. Overall, it is complete enough for an agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates fully by explaining every parameter: resource_types (with JSON format examples), namespace (with pod-only constraint), kubeconfig_path (with fallback behavior), and cluster_name (with source and precedence). This adds significant meaning beyond the bare schema fields, making it easy for an agent to construct valid inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: '批量查看 Node/Pod 的 CPU、内存使用' (batch view CPU/memory usage of Node/Pod), which is a specific verb+resource combination. It distinguishes itself from siblings like get_cluster_resource_usage by focusing on batch node/pod-level metrics, similar to kubectl top. This is unambiguous and specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context via '类似 kubectl top' and parameter constraints, but it does not explicitly state when to use this tool versus alternatives like get_cluster_resource_usage. It lacks explicit exclusions or alternative mentions, but the context is reasonably clear. This earns a 3 for implied usage without explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses defaults (namespace, only_failed, limit) and that limit avoids slowness with many Pods, but it does not explicitly state read-only behavior, what health criteria are used, or any permission requirements. A health check implies non-destructive action, but the implications are not made explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, then uses a clean Args list for parameters and a Returns line. Each bullet adds necessary information without fluff, making it easy to scan and parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description covers all parameters and core behavior but the Returns statement is vague ('Pod健康状态报告' - Pod health status report). It does not specify what fields or status values will be included, so an agent cannot predict the report structure precisely. Still, the essential execution context is covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 0% description coverage, but the Args block explains all 6 parameters with meaningful semantics: pod_name optional, namespace default, kubeconfig_path fallback to cluster_name, only_failed default False, and limit default 100 with rationale. This fully compensates for the schema's lack of descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with a specific verb and resource: '检查Pod健康状态' (check Pod health status), clearly distinguishing it from sibling tools like check_cluster_health and check_node_health. It also mentions a distinct capability, '支持筛选失败的Pod' (supports filtering failed Pods).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly establishes when to use the tool by naming the resource (Pod health) and using namespace/cluster parameters. It does not explicitly mention alternative tools or when-not-to-use scenarios, but the context is clear enough for an agent to select it over cluster/node health checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It reveals that the operation is a read (get), explains namespace filtering semantics, and clarifies cluster selection fallback logic. However, it does not mention potential side effects (likely none), error conditions, or output formatting beyond 'list of events', leaving some behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a one-line purpose, followed by a compact Args list and a Returns line. Every parameter is covered in a single informative line, with no redundant exposition. It is appropriately sized for a tool with five parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (list events) and the absence of an output schema, the description adequately covers the core aspects: what it does, how to specify namespace and cluster, optional filters, and return type. It could be more detailed about event ordering or the exact structure of the returned list, but it is sufficient for a straightforward read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description's Args section adds substantial meaning to every parameter: the special value 'all' for namespace, the precedence between kubeconfig_path and cluster_name, the purpose of event_type as a filter, and the role of limit. This completely compensates for the schema's lack of descriptions and provides actionable guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with '获取集群事件' (retrieve cluster events), which is a specific verb+resource combination that clearly indicates the tool's purpose. It is distinct from sibling tools like get_pod_logs or get_cluster_info, as 'cluster events' unambiguously refers to Kubernetes events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on how to scope the query (e.g., namespace='all' for all namespaces) and explains the cluster selection precedence between kubeconfig_path and cluster_name. It does not explicitly mention alternatives, but the purpose is self-evident and the parameter guidance effectively implies when 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the idle_timeout behavior (automatic stop after inactivity) and return values for each action. It does not elaborate on underlying network mechanics or prerequisites like kubeconfig validity, but it provides meaningful behavioral context beyond a bare function statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is organized with a one-line summary followed by an Args list and Returns section. It is somewhat long due to the 9 parameters, but every sentence adds value and the structure helps readability. It could be more concise, but the density is appropriate for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (9 parameters, no annotations, no output schema), the description is remarkably complete. It covers all parameters, describes the return values for each action, and explains conditional requirements and idle timeout behavior. No important usage aspect is left unexplained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description is the only source of parameter meaning. It explains every parameter in detail, including conditional requirements (pod_name/local_port/pod_port required for start, forward_id for stop), defaults (namespace default 'default'), ranges (ports 1-65535), and idle_timeout semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Pod 端口转发管理：启动、停止、列出转发会话' (Pod port forwarding management: start, stop, list sessions). This specifies the verb (manage/start/stop/list) and resource (port forwarding), effectively distinguishing it from sibling tools like get_pod_logs or exec_pod_command.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for each action (start/stop/list) and the parameters required for each. It does not explicitly name alternative tools for port forwarding, but within the sibling set no other tool handles port forwarding. Therefore, it gives sufficient guidance on when 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.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and covers it well: it explains direction-specific behavior, encoding for binary files, how local_path changes the flow, and return values. It also notes that to_pod file writes are confirmed and from_pod returns content or a saved path.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a one-line purpose, then uses a structured Args list and a Returns note. Every sentence adds value, and the information density is high without being verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 10-parameter, two-direction file-copy tool with no output schema, the description covers all essential behavior: parameter meanings, direction logic, encoding, defaults, container selection, and return values. It is self-sufficient for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining every parameter, including conditional requirements (content is required when local_path is not specified), defaults (namespace=default, encoding=text), and formats (pod_paths as JSON array or single path). This goes far beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action: copy files between a Pod and the MCP client, and the Args section defines both directions (from_pod/to_pod). This clearly distinguishes it from siblings that inspect logs, execute commands, or manage clusters.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The Args give explicit usage conditions: direction values, when content is required, local_path alternatives, namespace default, multi-container requirement, and kubeconfig fallback logic. It does not explicitly mention when to avoid this tool in favor of a sibling, but the context is otherwise clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![k8s-mcp-server MCP server](https://glama.ai/mcp/servers/Tobewont/k8s-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/Tobewont/k8s-mcp-server)

Score Badge

Copy to your README.md:

[![k8s-mcp-server MCP server](https://glama.ai/mcp/servers/Tobewont/k8s-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/Tobewont/k8s-mcp-server)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Tobewont/k8s-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server