AlibabaCloud MCP Server

Official

by aliyun

Overview Schema Related Servers Score Discussions

Python

Remote

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 distinct purposes targeting specific resources (e.g., OSS buckets, ECS instances, RDS instances, monitoring metrics), but there is some overlap in monitoring tools like GetCpuloadavg15mData, GetCpuloadavg5mData, and GetCpuLoadavgData which differ only in time granularity and could be confusing. Overall, the boundaries are clear for the majority of tools.
Naming Consistency4/5
The naming follows a consistent verb_noun pattern (e.g., DescribeInstances, RunInstances, DeleteBucket) with minor deviations such as GetCpuloadavgData (mixed case) and ListBuckets vs. ListObjects. Most tools use camelCase with initial capitals, but a few like GetCpuloadavgData break this slightly, though the pattern remains largely predictable.
Tool Count3/5
With 34 tools, the count is borderline high for a cloud management server, as it covers multiple services (ECS, RDS, OSS, VPC, monitoring). While comprehensive, it may feel heavy and could be streamlined by grouping similar operations, but it's not extreme and aligns with the broad scope of Alibaba Cloud services.
Completeness4/5
The tool set provides good coverage for core cloud operations including CRUD for instances, buckets, and monitoring, with lifecycle management (create, start, stop, reboot, delete). Minor gaps exist, such as no explicit update tools for instances or buckets, but agents can work around this using existing tools like ReplaceSystemDisk or by combining operations.
Average 2.9/5 across 34 of 34 tools scored. Lowest: 2.1/5.
See the Tool Scores section below for per-tool breakdowns.
- 2 of 2 community issues answered or closed in the last 6 months
- 0 commits in the last 12 weeks
- Last stable release on March 9, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It only states this is a query operation ('查询'), implying read-only behavior, but doesn't mention pagination (though parameters suggest it), rate limits, authentication requirements, error conditions, or what the response contains. For a 14-parameter query tool with no annotations, this minimal description leaves critical behavioral aspects undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (one Chinese sentence) but this brevity comes at the cost of being under-specified rather than efficiently informative. While it's front-loaded with the core action, it lacks the necessary detail for a tool with 14 parameters and complex filtering options. The single sentence doesn't earn its place by providing adequate guidance.
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 tool's complexity (14 parameters, no output schema, no annotations), the description is severely incomplete. It doesn't explain what information is returned about vswitches, how results are structured, whether this is a list or detailed view, or how to interpret the output. The description fails to compensate for the lack of output schema and annotations, leaving the agent with insufficient context to use the tool effectively.
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 description coverage is 100%, so the schema fully documents all 14 parameters with detailed descriptions, defaults, and examples. The description adds no parameter information beyond what's in the schema - it doesn't explain parameter relationships, common usage patterns, or which parameters are most important. With complete schema coverage, the baseline of 3 is appropriate as the description doesn't enhance parameter understanding.
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 '查询可组网的信息，内网按vswitch进行组网' translates to 'Query information for networking, internal network networking by vswitch.' This is vague and tautological - it essentially restates the tool name 'DescribeVSwitches' (describe virtual switches) without specifying what information is returned or how it's used. It mentions 'networking' but doesn't clarify if this lists vswitches, describes their properties, or provides configuration details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/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. With sibling tools like DescribeVpcs, DescribeSecurityGroups, and DescribeInstances available, there's no indication of when this specific vswitch query tool is appropriate versus other networking or infrastructure description tools. No prerequisites, exclusions, or comparison context is provided.
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 behavioral disclosure. It implies a read-only query operation but lacks details on permissions, rate limits, pagination behavior (beyond parameters like MaxResults and NextToken), or error handling. This leaves significant gaps for an agent to understand operational constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence in Chinese, which is concise but under-specified. It front-loads the core purpose but lacks structure and detail, making it efficient yet insufficient for clarity. It earns its place but could be more informative without verbosity.
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 complexity (37 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the return format, pagination strategy, or error scenarios, leaving the agent with inadequate context for effective use. The high parameter count and lack of behavioral info exacerbate this gap.
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 description coverage is 100%, so the schema already documents all 37 parameters thoroughly. The description adds no additional parameter semantics beyond implying filtering capabilities, resulting in a baseline score of 3 where the schema does the heavy lifting without extra value from the description.
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 the tool '查询实例列表' (queries instance lists) and '关联查询实例的详细信息' (associates with querying instance details), which clarifies it's a read operation for instances. However, it's vague about what 'instances' refer to (e.g., ECS instances) and doesn't differentiate from siblings like DescribeImages or DescribeDBInstances, leaving ambiguity in scope.
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 on when to use this tool versus alternatives is provided. The description mentions querying based on different request conditions but doesn't specify scenarios, prerequisites, or comparisons to siblings like DescribeAvailableResource or DescribeRegions, offering minimal contextual 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?
With no annotations provided, the description carries full burden for behavioral disclosure. '查询' (query) implies a read-only operation, but the description doesn't explicitly state this, nor does it mention pagination behavior, rate limits, authentication requirements, or what happens when no VPCs match filters. For a tool with 12 parameters and no annotation coverage, this is a significant gap in behavioral context.
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 extremely concise - a single Chinese phrase. While this is efficient and front-loaded, it may be too brief given the tool's complexity with 12 parameters. Every word earns its place, but the description could benefit from slightly more context without becoming verbose.
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 tool's complexity (12 parameters, no output schema, no annotations), the description is inadequate. It doesn't explain what the tool returns, how results are structured, pagination behavior, or error conditions. For a query tool with extensive filtering options, the single-phrase description leaves too much unspecified for effective agent use.
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 description coverage is 100%, so the schema already documents all 12 parameters thoroughly. The description adds no parameter-specific information beyond the generic '查询已创建的VPC' statement. According to guidelines, when schema coverage is high (>80%), the baseline is 3 even with no parameter info in the description.
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 '查询已创建的VPC' (Query created VPCs) clearly states the verb (query) and resource (VPCs), but it's vague about scope and filtering capabilities. It doesn't differentiate from sibling tools like DescribeInstances or DescribeSecurityGroups beyond mentioning VPCs specifically. The purpose is understandable but lacks specificity about what kind of query this performs.
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. There's no mention of prerequisites, typical use cases, or comparison to sibling tools like DescribeVSwitches or DescribeRegions. The agent must infer usage solely from the tool name and parameters.
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 this is a 'get' operation, implying read-only behavior, but doesn't specify authentication needs, rate limits, response format, or whether it returns real-time or historical data. For a monitoring tool with zero annotation coverage, this leaves significant gaps in understanding its 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 is a single, efficient sentence in Chinese that directly states the tool's function. It's front-loaded with the core purpose and contains no unnecessary words. However, it could be slightly more structured by explicitly mentioning the data source (AlibabaCloud ECS).
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 complexity of a monitoring tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the returned data looks like (e.g., numeric values, timestamps), how to interpret the load average, or error conditions. For a tool that fetches metric data, more context on the output is needed.
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 description coverage is 100%, with both parameters (InstanceIds and RegionId) well-documented in the schema. The description adds no additional parameter information beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the schema handles parameter documentation adequately.
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 '获取CPU五分钟平均负载指标数据' (Get CPU five-minute average load metric data) states a clear verb ('获取' - get) and resource (CPU load data), but it doesn't distinguish this tool from its siblings like GetCpuloadavg15mData or GetCpuLoadavgData. The purpose is understandable but lacks 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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over GetCpuloadavg15mData (15-minute average) or GetCpuLoadavgData (general load data), nor does it specify prerequisites or exclusions. Usage context is implied but not explicit.
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 only states what data is retrieved ('get disk partition total capacity metric data') without mentioning any behavioral traits such as whether this is a read-only operation, potential rate limits, authentication needs, or what the output format might be. This leaves significant gaps for an AI agent to understand how to invoke it effectively.
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 single, efficient sentence in Chinese that directly states the purpose without unnecessary words. It's appropriately sized for a simple data retrieval tool, though it could be more front-loaded with additional context if needed.
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 complexity of a data retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the returned data looks like (e.g., format, units), how it's structured, or any limitations (e.g., time ranges, aggregation). This makes it inadequate for an AI agent to fully understand the tool's behavior and output.
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?
The description adds no meaning beyond what the input schema provides. With 100% schema description coverage, the schema already documents both parameters (InstanceIds and RegionId) clearly. The description doesn't explain how these parameters relate to retrieving disk total capacity data, so it meets the baseline of 3 where the schema does the heavy lifting.
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 '获取磁盘分区总容量指标数据' (Get disk partition total capacity metric data) states the verb ('get') and resource ('disk partition total capacity metric data'), but it's somewhat vague about what exactly is being retrieved. It doesn't clearly distinguish from sibling tools like GetDiskUsageData or GetDiskUsedData, which also deal with disk metrics but for different aspects (usage vs. used vs. total capacity).
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. With sibling tools like GetDiskUsageData and GetDiskUsedData, there's no indication of when total capacity data is needed compared to usage or used data, nor any prerequisites or exclusions mentioned in the description.
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 full burden but only states what the tool does ('获取' - get) without behavioral details. It doesn't disclose whether this is a read-only operation, requires specific permissions, has rate limits, returns time-series vs snapshot data, or what format/units the data comes in. For a metric tool with zero annotation coverage, this is insufficient.
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 single, efficient sentence in Chinese that directly states the tool's function without fluff. However, it could be more front-loaded with critical context (e.g., specifying it's for AlibabaCloud ECS instances, which is only in the schema).
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 metric-fetching tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'memory utilization metric data' entails (e.g., percentages, time ranges, aggregation), return format, or error conditions. Given the complexity of cloud monitoring data and lack of structured output, more context is needed.
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 description coverage is 100%, with both parameters (InstanceIds, RegionId) well-documented in the schema. The description adds no parameter-specific information beyond implying memory metrics are fetched, which the schema already covers through parameter names and descriptions. Baseline 3 is appropriate when schema does the heavy lifting.
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 '获取内存利用率指标数据' (Get memory utilization metric data) states a clear verb ('获取' - get) and resource ('内存利用率指标数据' - memory utilization metric data), but it's vague about scope and doesn't differentiate from siblings like GetMemUsedData. It doesn't specify whether this is historical, real-time, aggregated, or per-instance data.
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 on when to use this tool versus alternatives like GetMemUsedData or other metric tools (GetCpuUsageData, GetDiskUsageData). The description doesn't mention prerequisites, timing considerations, or comparison with sibling tools, leaving the agent to infer 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 behavioral disclosure. It states the tool queries instance lists, implying a read-only operation, but doesn't confirm safety (e.g., no mutations), discuss rate limits, authentication needs, pagination behavior (implied by NextToken but not explained), or error handling. For a tool with 29 parameters and no annotations, this leaves significant behavioral gaps.
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 single, efficient sentence in Chinese: '该接口用于查询RDS的实例列表.' It's front-loaded with the core purpose (querying RDS instances) and has zero redundant information. Every word earns its place, making it highly concise and well-structured for quick understanding.
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 complexity (29 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain the return format (e.g., list structure, fields), pagination (hinted by NextToken but not described), filtering logic, or error cases. For a query tool with many parameters and no structured output, the description should provide more context to guide the agent effectively.
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 description coverage is 100%, with detailed parameter descriptions in the input schema (e.g., Category with enum values, MaxResults with defaults). The tool description adds no parameter-specific information beyond the schema. According to guidelines, when coverage is high (>80%), the baseline is 3 even with no param info in the description, which applies here as the schema fully documents parameters.
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 '该接口用于查询RDS的实例列表' (This interface is used to query RDS instance lists) states the verb ('query') and resource ('RDS instance lists'), making the purpose clear. However, it's vague about scope (e.g., all instances vs. filtered) and doesn't distinguish from sibling tools like 'DescribeInstances' (which likely queries compute instances) or 'DescribeRegions' (which queries regions). It provides basic clarity but lacks specificity for 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?
The description offers no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., requiring RegionId), exclusions, or comparisons to sibling tools such as 'DescribeInstances' (for compute instances) or 'DescribeRegions' (for region data). Without any usage context, the agent must infer from tool names alone, which is insufficient for reliable selection.
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 only states what data is retrieved ('disk utilization metric data') without disclosing behavioral traits like whether this is a real-time or historical query, if it requires specific permissions, rate limits, or what the output format looks like (e.g., JSON structure, units). This is inadequate for a tool with no annotation coverage.
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 single, efficient sentence in Chinese that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (retrieving metrics from a cloud service), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'disk utilization metric data' includes (e.g., percentages, timestamps, aggregation), how results are returned, or any prerequisites, leaving significant gaps for an AI agent to use the tool effectively.
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 description coverage is 100%, with clear descriptions for InstanceIds ('AlibabaCloud ECS instance ID List') and RegionId ('AlibabaCloud region ID'). The description adds no parameter semantics beyond the schema, but the baseline is 3 since the schema adequately documents the parameters.
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 '获取磁盘利用率指标数据' (Get disk utilization metric data) states a clear verb ('get') and resource ('disk utilization metric data'), but it's vague about what specific metrics are retrieved. It doesn't distinguish from siblings like GetDiskTotalData or GetDiskUsedData, leaving ambiguity about what 'utilization' encompasses (e.g., percentage, raw values, or both).
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. With siblings like GetDiskTotalData and GetDiskUsedData, the description doesn't clarify if this tool combines both metrics or serves a different purpose, leaving the agent to guess based on tool names alone.
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 only states it's a query tool ('查询'), implying it's read-only, but doesn't clarify if it's safe, idempotent, or has side effects. It lacks details on rate limits, authentication needs, error handling, or response format. For a tool with 23 parameters and no annotations, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that lists parameters but is somewhat cluttered. It front-loads the purpose but includes parameter names without clear structuring. It could be more streamlined by focusing on the core action and omitting the parameter list, as the schema covers them. However, it's not overly verbose.
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 complexity (23 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the tool's behavior, output format, or error conditions. While the schema covers parameters, the description fails to provide necessary context for safe and effective use, especially for a query tool with many filtering options.
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 description coverage is 100%, so the schema already documents all 23 parameters thoroughly. The description mentions parameters like ImageId, Filter, and '镜像被使用场景' (image usage scenario) but doesn't add meaningful context beyond what's in the schema. It lists parameters without explaining their interplay or typical combinations. Baseline 3 is appropriate since the schema does the heavy lifting.
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 the tool's purpose: '查询您可以使用的镜像资源列表' (query the list of image resources you can use). It specifies the verb '查询' (query) and resource '镜像资源列表' (image resource list), making the action explicit. However, it doesn't differentiate from sibling tools like DescribeInstances or DescribeRegions, which are also query tools but for different 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?
The description provides no guidance on when to use this tool versus alternatives. It mentions parameters like ImageId and Filter but doesn't explain scenarios where this tool is preferred over other query tools or when it should be avoided. There's no mention of prerequisites, dependencies, or typical 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action is deletion, implying a destructive operation, but does not specify critical details such as whether deletion is permanent, requires specific permissions, has rate limits, or what happens if the bucket contains objects. This is a significant gap for a high-risk 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 single, direct sentence that efficiently conveys the core action without unnecessary words. It is front-loaded with the key information ('删除指定的OSS存储空间'), making it highly concise and well-structured for quick understanding.
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 tool's complexity (destructive deletion with 2 parameters) and the absence of both annotations and an output schema, the description is incomplete. It fails to address behavioral risks, usage prerequisites, or expected outcomes, which are essential for safe and effective tool invocation in this context.
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 description coverage is 100%, with clear descriptions for both parameters (BucketName and RegionId). The description does not add any semantic details beyond the schema, such as format constraints or examples. Since the schema adequately documents the parameters, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('删除' meaning 'delete') and the resource ('OSS存储空间' meaning 'OSS storage space'), which is specific and unambiguous. However, it does not distinguish this tool from sibling tools like 'DeleteInstances' or 'ListBuckets', as it lacks context about what makes this deletion unique to OSS buckets versus other 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?
The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., bucket must be empty), exclusions (e.g., cannot delete if in use), or refer to related tools like 'ListBuckets' for verification. This leaves the agent without context for proper tool selection.
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 full responsibility for behavioral disclosure. It only states the query function without mentioning whether this is a read-only operation, if it requires authentication, what the response format looks like, or any rate limits. For a query tool with zero annotation coverage, this leaves significant behavioral aspects undocumented.
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 single, efficient sentence that directly states the tool's function. It's appropriately sized for a query tool and front-loads the core purpose without unnecessary elaboration. Every word contributes to understanding what the tool does.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 is incomplete. It doesn't explain what the query returns (e.g., region names, IDs, availability statuses), how results are structured, or any behavioral constraints. For a tool that presumably returns important infrastructure metadata, this leaves too much unspecified for effective agent use.
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 description coverage is 100%, meaning all four parameters are thoroughly documented in the input schema with descriptions, examples, and allowed values. The description mentions '计费方式' (billing method) and '资源类型' (resource type) which correspond to InstanceChargeType and ResourceType parameters, but adds no additional semantic context beyond what the schema already provides. The baseline score of 3 is appropriate when the schema does the heavy lifting.
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 the tool's purpose as querying a list of region information based on billing methods and resource types. It uses specific verbs ('查询' - query) and resources ('地域信息列表' - region information list), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like DescribeZones or DescribeAvailableResource, which appear to serve similar informational purposes.
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 doesn't mention sibling tools like DescribeZones (which might provide zone-level information) or DescribeAvailableResource (which might focus on resource availability rather than region metadata). There's no context about prerequisites, typical use cases, 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 provided, the description carries full burden but lacks behavioral details. It states it's a query tool, implying read-only behavior, but doesn't disclose pagination mechanics (implied by MaxResults/NextToken but not explained in description), rate limits, authentication needs, or error handling. The description is too minimal for a tool with 17 parameters and no output schema.
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 single, efficient sentence in Chinese that directly states the tool's purpose and key filtering capabilities. It's front-loaded with the main function and wastes no words, making it highly concise and well-structured for quick understanding.
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 tool's complexity (17 parameters, no output schema, no annotations), the description is inadequate. It doesn't explain the return format, pagination behavior, or common use cases. For a list/query tool with many parameters, more context is needed to guide effective usage, especially without annotations or output schema.
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 description coverage is 100%, so the schema fully documents all 17 parameters. The description adds minimal value by listing example filter parameters (region, security group ID, type) but doesn't provide additional context beyond what's in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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 the tool's purpose: '查询安全组基本信息列表' (query security group basic information list). It specifies the verb (query) and resource (security groups), and mentions filtering parameters like region, security group ID, and type. However, it doesn't explicitly differentiate from sibling tools like DescribeInstances or DescribeVpcs, which have similar query patterns for different 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?
The description provides no guidance on when to use this tool versus alternatives. It mentions filtering parameters but doesn't specify scenarios, prerequisites, or exclusions. For example, it doesn't clarify if this is for listing all security groups versus detailed inspection of a single group, or how it relates to other Describe* tools in the sibling list.
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 the tool queries information, implying it's a read-only operation, but doesn't confirm this or describe other traits like rate limits, authentication needs, error conditions, or pagination. For a tool with 5 parameters and no annotations, this minimal description leaves critical behavioral aspects unspecified.
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 single, efficient sentence in Chinese that directly states the tool's purpose and key parameters. It's front-loaded with no wasted words, making it easy to parse quickly. Every part of the sentence contributes to understanding the tool's function.
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 complexity (5 parameters, no output schema, no annotations), the description is insufficiently complete. It lacks information on the return format (e.g., what fields are included in the list), error handling, or typical use cases. For a query tool with multiple parameters and no structured output documentation, users need more context to use it effectively.
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?
The schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly with descriptions, examples, and defaults. The description adds minimal value by listing '地域ID、计费方式等参数' (region ID, billing method, and other parameters), which loosely maps to RegionId and InstanceChargeType, but doesn't provide additional context or meaning beyond what's in the schema. This meets the baseline for high schema coverage.
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 the tool's purpose: '查询可用区信息列表' (query availability zone information list) with filtering by '地域ID、计费方式等参数' (region ID, billing method, and other parameters). It specifies both the action (query/list) and resource (availability zones), but doesn't explicitly differentiate from sibling tools like DescribeRegions or DescribeAvailableResource, which appear related.
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. The description mentions parameters but doesn't explain the context or prerequisites for use, such as whether it's for resource provisioning or general information lookup. With many sibling tools in the server (e.g., DescribeRegions, DescribeAvailableResource), the lack of comparative guidance is a significant gap.
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 behavioral disclosure. While '获取' (get) implies a read operation, the description doesn't mention authentication requirements, rate limits, error conditions, or what format the data returns. For a cloud monitoring tool with no annotation coverage, this leaves significant behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient Chinese sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for what it communicates, though it could be more helpful with additional context.
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 cloud monitoring tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the returned data looks like, what units are used, whether it's real-time or historical data, or how to interpret the results. The agent would need to guess about the tool's behavior and output format.
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?
With 100% schema description coverage, the input schema already documents both parameters well. The description adds no additional parameter information beyond what's in the schema. The baseline score of 3 reflects adequate parameter documentation through the schema alone, though the description contributes nothing extra.
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 the action ('获取' - get/retrieve) and resource ('CPU十五分钟平均负载指标数据' - CPU 15-minute average load metric data), making the purpose understandable. However, it doesn't differentiate from its siblings like GetCpuloadavg5mData or GetCpuLoadavgData, which appear to be similar CPU load monitoring tools with different timeframes.
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. With siblings like GetCpuloadavg5mData, GetCpuLoadavgData, and GetCpuUsageData, there's no indication of what distinguishes this 15-minute average tool from other CPU monitoring tools, leaving the agent to guess based on naming alone.
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 it 'gets' data, implying a read-only operation, but doesn't mention any behavioral traits such as authentication requirements, rate limits, error conditions, or what the returned data looks like (e.g., format, units). This leaves significant gaps for a tool interacting with a cloud service.
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 single, efficient sentence in Chinese that directly states the tool's purpose without any unnecessary words or fluff. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of interacting with AlibabaCloud ECS instances and the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like authentication, error handling, or data format, and there's no output schema to clarify return values. This makes it inadequate for safe and effective tool invocation in a cloud environment.
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?
The schema description coverage is 100%, with clear descriptions for both parameters (InstanceIds and RegionId). The description adds no additional parameter semantics beyond what the schema provides, such as explaining the format of InstanceIds or implications of RegionId. Given the high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('获取' meaning 'get') and resource ('CPU一分钟平均负载指标数据' meaning 'CPU one-minute average load metric data'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from its siblings GetCpuloadavg15mData and GetCpuloadavg5mData, which appear to be similar tools for different time intervals.
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. There are no explicit instructions about when/when-not to use it, nor does it mention sibling tools like GetCpuloadavg15mData or GetCpuloadavg5mData for different time intervals, leaving the agent to infer 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 behavioral disclosure. It states '获取' (get), implying a read-only operation, but doesn't clarify aspects like authentication requirements, rate limits, data freshness, or response format. For a tool with no annotations, this leaves significant behavioral gaps.
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 single, efficient sentence in Chinese that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a read operation with potential complexity (e.g., data aggregation, time ranges), the description is incomplete. It lacks details on return values, error handling, or operational context, making it inadequate for full agent understanding without external inference.
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 description coverage is 100%, with clear descriptions for both parameters (InstanceIds and RegionId). The description adds no additional parameter semantics beyond what the schema provides, such as format details or constraints. With high schema coverage, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('获取' meaning 'get') and resource ('ECS实例的CPU使用率数据' meaning 'ECS instance CPU usage data'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like GetCpuloadavgData or GetMemUsageData, which target different metrics, leaving some ambiguity about when to choose this specific CPU metric tool.
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 doesn't mention sibling tools like GetCpuloadavgData (for load averages) or GetMemUsageData (for memory), nor does it specify prerequisites, contexts, or exclusions for usage, leaving the agent to infer based on tool names alone.
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 it 'gets' data, implying a read-only operation, but doesn't clarify aspects like whether it requires specific permissions, rate limits, data freshness, or error handling. For a tool with no annotations, this leaves significant gaps in understanding its 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 is a single, efficient sentence in Chinese that directly states the purpose without unnecessary words. It's appropriately sized for a simple data retrieval tool, though it could be slightly more informative without losing conciseness.
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?
Given the tool's moderate complexity (retrieving metric data with two parameters), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavior, output format, or usage context, which are important for an agent to operate effectively in this server environment with many sibling tools.
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?
The description adds no parameter-specific information beyond what's in the input schema, which has 100% description coverage. It doesn't explain the relationship between InstanceIds and RegionId or provide usage examples. With high schema coverage, the baseline is 3, as the schema adequately documents parameters without extra help from the description.
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 '获取磁盘分区使用量指标数据' (Get disk partition usage metric data) clearly states the verb (get) and resource (disk partition usage metrics). It distinguishes from siblings like GetDiskTotalData (total disk data) and GetDiskUsageData (usage data without specifying partition focus), though the distinction could be more explicit.
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 like GetDiskUsageData or GetDiskTotalData. It lacks context about prerequisites, such as needing AlibabaCloud ECS instances, or exclusions, leaving the agent to infer usage from the input schema alone.
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 behavioral disclosure. It states the action ('get') but doesn't describe what the tool returns (e.g., format, units, time range), whether it's a read-only operation, potential rate limits, or authentication needs. This leaves significant gaps in understanding how the tool behaves beyond its basic purpose.
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 single, efficient sentence in Chinese that directly states the tool's purpose without any unnecessary words or fluff. It is front-loaded and appropriately sized for a simple data retrieval tool, making it easy to parse quickly.
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 tool's complexity (data retrieval with parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the return values (e.g., what 'memory usage metric data' includes), potential errors, or behavioral traits like whether it's safe or has side effects. This leaves the agent with insufficient context to use the tool effectively beyond basic parameter input.
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?
The schema description coverage is 100%, with clear descriptions for both parameters (InstanceIds and RegionId). The description adds no additional parameter semantics beyond what the schema provides, such as explaining what 'memory usage metric data' entails or how parameters affect the output. This meets the baseline score since the schema adequately documents the parameters.
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 the verb ('获取' meaning 'get') and resource ('内存使用量指标数据' meaning 'memory usage metric data'), making the purpose understandable. However, it doesn't explicitly distinguish this tool from its sibling 'GetMemUsageData', which appears to be a related memory metric tool, leaving some ambiguity about their 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?
The description provides no guidance on when to use this tool versus alternatives like 'GetMemUsageData' or other memory-related tools. It lacks context about prerequisites, such as needing instance IDs or region specifications, and offers no exclusions or recommendations for when not to use it.
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 it retrieves file information, implying a read-only operation, but doesn't specify whether this is safe, if it requires specific permissions, what the output format is, or any rate limits. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and constraints.
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 single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's front-loaded with the core action and resource, making it easy to understand at a glance. Every part of the sentence contributes to clarifying the tool's function.
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 complexity of interacting with cloud storage (OSS), no annotations, and no output schema, the description is incomplete. It doesn't explain what 'file information' includes, how results are returned, pagination, error handling, or authentication needs. For a tool that likely returns a list of objects with metadata, more context is needed to use it effectively.
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?
The schema description coverage is 100%, with clear descriptions for all three parameters (BucketName, Prefix, RegionId). The description adds no additional parameter semantics beyond what the schema provides, such as explaining how Prefix filters results or default behaviors. Since the schema does the heavy lifting, the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('获取' meaning 'get' or 'retrieve') and resource ('所有文件信息' meaning 'all file information' from an OSS storage space). It specifies the scope ('指定OSS存储空间中' meaning 'in the specified OSS storage space'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like ListBuckets, which likely lists buckets rather than objects within a bucket, so it misses full 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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, such as needing proper authentication or permissions, or compare it to other tools like ListBuckets or DescribeInstances. The context is implied by the tool name and description, but no explicit usage rules are given.
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 full burden for behavioral disclosure. While 'creates' implies a write/mutation operation, it doesn't describe permissions required, whether the operation is idempotent, what happens on failure, or any rate limits. For a bucket creation tool with zero annotation coverage, this leaves significant behavioral gaps.
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 single, efficient sentence that states the core purpose without any wasted words. It's appropriately sized for a creation operation and gets straight to the point.
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 bucket creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, what permissions are needed, whether the bucket name must be globally unique, or what the response contains. The 100% schema coverage helps with parameters, but behavioral and operational context is missing.
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 description coverage is 100%, so the schema already documents all 4 parameters thoroughly with descriptions, defaults, and value explanations. The description adds no additional parameter information beyond what's in the schema, meeting the baseline expectation when schema does the heavy lifting.
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 the action ('创建一个新的' - creates a new) and resource ('OSS存储空间' - OSS storage space/bucket). It's specific about what the tool does, though it doesn't explicitly differentiate from sibling tools like ListBuckets or DeleteBucket in the description text itself.
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. There's no mention of prerequisites, when creation is appropriate versus listing existing buckets, or what happens if a bucket with the same name already exists. The sibling tool ListBuckets exists but isn't referenced.
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 full burden. It mentions '批量替换' (batch replacement) and '更换操作系统' (OS change), which implies a destructive, write operation. However, it lacks critical behavioral details: whether instances need to be stopped first, if data loss occurs, required permissions, rate limits, or what the response looks like. For a destructive tool with zero annotation coverage, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Chinese: '批量替换ECS实例的系统盘，更换操作系统' (Batch replace ECS instance system disks, change the operating system). It's front-loaded with the core action and resource, with no wasted words or redundant information.
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 complexity of a destructive batch operation (replacing system disks and changing OS), no annotations, and no output schema, the description is incomplete. It lacks essential context: prerequisites (e.g., instance state), side effects (data loss, downtime), error handling, and response format. For a high-stakes tool like this, the description should provide more guidance.
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 description coverage is 100%, so the schema already documents all three parameters (ImageId, InstanceIds, RegionId) with basic descriptions. The description adds no additional parameter semantics beyond implying that ImageId relates to the new OS and InstanceIds are for batch operations. Baseline 3 is appropriate when the schema does the heavy lifting.
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 the action ('批量替换' - batch replace) and resource ('ECS实例的系统盘' - ECS instance system disk), with the additional context of '更换操作系统' (changing the operating system). It's specific about what the tool does, though it doesn't explicitly differentiate from sibling tools like 'RebootInstances' or 'RunInstances' which might be related but serve different purposes.
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 doesn't mention prerequisites (e.g., instance must be stopped), exclusions, or compare it to siblings like 'RunInstances' (which creates new instances) or 'RebootInstances' (which restarts without disk replacement). Usage is implied only by the action described.
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 full burden. It states the query purpose but lacks behavioral details: it doesn't specify if this is a read-only operation (implied but not explicit), whether it requires authentication, rate limits, error conditions, or the format of returned data. For a quota query tool with zero annotation coverage, this is a significant gap in transparency.
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 single, efficient sentence in Chinese that lists the quota types covered. It's front-loaded with the core purpose and avoids redundancy. However, it could be slightly more structured by separating the query action from the quota list for better readability.
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 complexity (querying multiple quota types across regions), lack of annotations, and no output schema, the description is incomplete. It doesn't explain the return format, error handling, or authentication needs. While it covers the purpose well, it misses critical behavioral and output context needed for effective tool use.
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 description coverage is 100%, so the schema already documents all three parameters (AttributeName, RegionId, ZoneId) in detail. The description adds no parameter-specific information beyond implying a regional context. Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't enhance parameter understanding (e.g., explaining AttributeName options beyond what's in 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 specific action ('查询' meaning 'query') and the exact resource ('ECS资源配额' meaning 'ECS resource quotas') in a specific context ('在一个阿里云地域下' meaning 'in an Alibaba Cloud region'). It distinguishes from siblings by focusing on account-level quotas rather than instance operations (e.g., RunInstances) or resource listings (e.g., DescribeInstances).
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 doesn't mention prerequisites (e.g., needing RegionId), exclusions, or compare with similar tools like DescribeAvailableResource (which might show available resources rather than quotas). Usage is implied only through the query purpose.
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 full burden. It mentions listing buckets in a specified region but doesn't disclose behavioral traits like pagination, rate limits, authentication requirements, error conditions, or what 'all' means (e.g., whether it includes hidden or system buckets). For a read operation with no annotation coverage, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence in Chinese that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded with the core action.
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?
Given the tool's moderate complexity (listing resources with filtering), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavior, output format, or usage context. It meets the minimum viable threshold but has clear gaps in completeness.
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 description coverage is 100%, so the schema already documents both parameters (Prefix and RegionId) with descriptions. The description adds no additional meaning beyond implying regional filtering, which is already covered by the RegionId parameter in the schema. Baseline 3 is appropriate when the schema does the heavy lifting.
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 the action ('列出' - list) and resource ('OSS存储空间' - OSS buckets) with geographic scope ('指定区域' - specified region). It distinguishes from sibling tools like ListObjects (which lists objects within buckets) but doesn't explicitly differentiate from other list-like tools like DescribeInstances or DescribeRegions.
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 doesn't mention prerequisites, when not to use it, or compare it to similar tools like DescribeRegions (which might list regions rather than buckets). The context is implied but not explicit.
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 full burden for behavioral disclosure. It mentions '批量重启' (batch reboot) which implies a destructive/mutative operation affecting multiple instances, but doesn't disclose critical behavioral aspects like: whether this requires specific permissions, potential service interruption duration, whether instances must be in a particular state, error handling for partial failures, or confirmation requirements. The description is insufficient for a mutation tool with zero annotation coverage.
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 single, efficient Chinese sentence that communicates the core purpose and context. It's appropriately sized without unnecessary elaboration, though it could be slightly more front-loaded by stating the primary action more prominently.
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 destructive batch operation tool with no annotations and no output schema, the description is incomplete. It doesn't address critical aspects like: what happens during reboot (service interruption), whether instances must be stopped first, error behavior for invalid InstanceIds, return values or confirmation, or rate limits. The combination of mutation tool + zero annotations + no output schema requires more comprehensive description.
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 description coverage is 100%, so the schema already documents all three parameters (InstanceIds, RegionId, ForceStop). The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain parameter interactions, format details, or usage examples. Baseline 3 is appropriate when the schema does the heavy lifting.
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 the action ('批量重启' - batch reboot) and target resource ('ECS实例' - ECS instances), making the purpose understandable. It distinguishes from some siblings like StartInstances/StopInstances by specifying reboot rather than power state changes, though it doesn't explicitly differentiate from RebootRDSInstances which reboots a different resource type.
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 some usage context ('适用于需要同时管理和重启多台ECS实例的场景' - suitable for scenarios requiring simultaneous management and reboot of multiple ECS instances), which implies batch operations. However, it doesn't explicitly state when to use this versus alternatives like StopInstances+StartInstances or RebootRDSInstances, nor does it mention prerequisites 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 of behavioral disclosure. It mentions batch restarting but does not cover critical aspects such as whether this operation is destructive (likely yes, as rebooting disrupts service), required permissions, rate limits, or what happens during the reboot process. This leaves significant gaps for an agent to understand the tool's 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 is a single, efficient sentence in Chinese that front-loads the core purpose ('批量重启RDS实例') and adds context. It avoids redundancy and wastes no words, though it could be slightly more structured for clarity.
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 complexity of a batch restart operation, no annotations, and no output schema, the description is incomplete. It fails to address behavioral traits (e.g., destructiveness, permissions), output expectations, or error handling, which are crucial for an agent to use this tool effectively in a production environment.
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?
The schema description coverage is 100%, with clear descriptions for both parameters (InstanceIds and RegionId). The description adds no additional parameter semantics beyond what the schema provides, such as format details or constraints. According to the rules, with high schema coverage (>80%), the baseline score is 3, as the schema adequately documents the parameters.
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 the action ('批量重启' meaning 'batch restart') and resource ('RDS实例' meaning 'RDS instances'), which is specific and unambiguous. However, it does not explicitly differentiate from sibling tools like 'RebootInstances' or 'StartRDSInstances', though the focus on RDS instances implies some distinction.
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 implied usage context by stating it's for scenarios requiring simultaneous management and restart of multiple RDS instances. However, it lacks explicit guidance on when to use this tool versus alternatives like 'RebootInstances' (for non-RDS instances) or 'StartRDSInstances' (for starting rather than restarting), and does not mention prerequisites 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 provided, the description carries the full burden of behavioral disclosure. It mentions the tool runs commands on instances but doesn't describe critical behavioral aspects: what permissions are required, whether commands run synchronously or asynchronously, how results are returned, potential side effects, error handling, or rate limits. For a tool that executes commands on cloud instances (a potentially powerful/destructive operation), this is a significant gap in transparency.
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 appropriately concise - two sentences that convey the core purpose and usage context without unnecessary elaboration. It's front-loaded with the main functionality. While efficient, it could potentially benefit from slightly more structure (e.g., separating purpose from examples more clearly).
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 complexity of a command execution tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (success/failure indicators, command outputs, execution IDs), doesn't mention authentication requirements, doesn't warn about potential destructive commands, and doesn't provide error handling context. For a tool that could significantly impact cloud instances, more comprehensive guidance is needed.
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 description coverage is 100%, so the schema already documents all four parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (it doesn't explain Command syntax, InstanceIds format, or RegionId implications). According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.
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 the tool's purpose: '批量在多台ECS实例上运行云助手命令' (batch run cloud assistant commands on multiple ECS instances). It specifies the verb ('运行' - run) and resource ('ECS实例' - ECS instances), and mentions the multi-instance scope. However, it doesn't explicitly differentiate from potential sibling tools like 'RunInstances' (which likely provisions instances rather than running commands on existing ones).
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 some usage context: '适用于需要同时管理多台ECS实例的场景，如应用程序管理和资源标记操作等' (suitable for scenarios requiring simultaneous management of multiple ECS instances, such as application management and resource tagging operations). This implies when to use it (batch management scenarios) but doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools. The guidance is helpful but not comprehensive.
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 full burden for behavioral disclosure. It mentions the batch creation capability but doesn't disclose critical behavioral traits: whether this is a destructive/write operation (implied but not stated), what permissions are required, whether there are rate limits, what happens on failure (partial success?), or what the return format looks like. For a complex creation tool with 7 parameters, 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 appropriately concise - two sentences that efficiently convey the core purpose and usage scenarios. It's front-loaded with the main action ('批量创建ECS实例') followed by context. There's no wasted verbiage, though it could potentially benefit from slightly more detail given the tool's complexity.
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 this is a complex instance creation tool with 7 parameters, no annotations, and no output schema, the description is insufficiently complete. It doesn't address critical aspects: what the tool returns (instance IDs? status?), error conditions, permissions required, cost implications, or behavioral details like whether instances start automatically after creation. The description should do more to compensate for the lack of structured metadata.
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 description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. It mentions batch creation which relates to the 'Amount' parameter, but doesn't provide additional context about parameter interactions, dependencies, or usage patterns. Baseline 3 is appropriate when schema does the heavy lifting.
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 the tool's purpose: '批量创建ECS实例' (batch create ECS instances). It specifies the verb (create) and resource (ECS instances), and adds context about batch operations. However, it doesn't explicitly differentiate from potential siblings like 'StartInstances' or 'DescribeInstances' beyond mentioning batch creation scenarios.
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 some usage context: '适用于需要同时创建多台ECS实例的场景，例如应用部署和高可用性场景' (suitable for scenarios requiring simultaneous creation of multiple ECS instances, such as application deployment and high availability scenarios). This gives implied guidance about when to use it (batch creation needs), but doesn't explicitly state when NOT to use it or mention alternatives like creating single instances through other means.
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 behavioral disclosure. While it mentions this is for batch operations and gives usage scenarios, it doesn't disclose important behavioral aspects: whether this requires specific permissions, what happens if some instances fail to start, whether there are rate limits, what the expected response looks like, or whether this operation is idempotent. For a mutation tool with zero annotation coverage, 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 appropriately concise with two clear sentences. The first sentence states the core functionality, and the second provides usage context. There's no wasted verbiage or unnecessary repetition. However, it could be slightly more front-loaded by making the batch nature more prominent earlier.
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 insufficiently complete. It doesn't explain what the tool returns, what error conditions might occur, or important behavioral constraints. Given that this performs a potentially significant operation (starting cloud instances), more contextual information about permissions, idempotency, and failure modes would be valuable.
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?
The description doesn't mention any parameters directly, but with 100% schema description coverage, the schema already documents both parameters (InstanceIds and RegionId) adequately. The description's mention of '批量' (batch) operation aligns with the InstanceIds array parameter, but adds minimal semantic value beyond what the schema provides. The baseline of 3 is appropriate when the schema does the heavy lifting.
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 the action ('批量启动' - batch start) and resource ('ECS实例' - ECS instances), making the purpose immediately understandable. It distinguishes from siblings like StopInstances and RebootInstances by focusing on starting rather than stopping or restarting. However, it doesn't explicitly differentiate from StartRDSInstances (which starts RDS instances rather than ECS instances).
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 usage context with examples ('应用部署和高可用性场景' - application deployment and high availability scenarios), which helps understand when this tool might be appropriate. However, it doesn't explicitly state when NOT to use this tool or mention clear alternatives like RunInstances (for creating and starting new instances) or RebootInstances (for restarting already running instances).
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 full burden for behavioral disclosure. It mentions batch operations and use cases but fails to disclose critical behavioral traits such as permissions required, whether this is a destructive/mutative operation (implied by 'start' but not explicit), potential side effects, rate limits, or what happens if instances are already running. This leaves significant gaps for an agent to understand the tool's 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 is concise with two sentences that efficiently convey purpose and usage context without unnecessary elaboration. It is front-loaded with the core action and resource, followed by contextual examples. There's minimal waste, though it could be slightly more structured with explicit bullet points for use cases.
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 tool's complexity (batch operation on cloud resources), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral risks, output format, error conditions, or prerequisites like authentication. For a mutative tool with no structured safety hints, this leaves the agent under-informed about critical operational aspects.
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 description coverage is 100%, providing good documentation for both parameters (InstanceIds and RegionId). The description adds no additional parameter semantics beyond what's in the schema, such as format details for InstanceIds or RegionId constraints. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
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 the action ('批量启动' - batch start) and resource ('RDS实例' - RDS instances), making the purpose evident. It distinguishes from sibling tools like 'StartInstances' by specifying RDS instances, though it doesn't explicitly contrast with 'StopRDSInstances' or other RDS 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 usage context ('适用于需要同时管理和启动多台RDS实例的场景，例如应用部署和高可用性场景' - suitable for scenarios requiring simultaneous management and startup of multiple RDS instances, such as application deployment and high availability scenarios), which implies when to use it. However, it lacks explicit guidance on when NOT to use it or alternatives like 'StartInstances' for non-RDS instances.
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 full burden. It mentions batch stopping but lacks critical behavioral details: whether this is destructive (likely yes, but not stated), permission requirements, rate limits, error handling, or what happens to running workloads. The description is too vague for a mutation tool with no annotation coverage.
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 single, efficient sentence that front-loads the core purpose. It avoids unnecessary words, though it could be slightly more structured by separating purpose from usage context.
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 this is a mutation tool (stopping instances) with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., destructiveness, side effects), error cases, or return values, which are crucial for safe agent operation in a cloud environment.
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 description coverage is 100%, so the schema already documents all parameters (InstanceIds, ForceStop, RegionId). The description adds no additional parameter semantics beyond implying batch operations via '批量' (batch), which is redundant with the array type of InstanceIds. Baseline 3 is appropriate when schema does the heavy lifting.
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 the action ('批量停止' - batch stop) and resource ('ECS实例' - ECS instances), making the purpose evident. It distinguishes from siblings like StopRDSInstances by specifying ECS instances, but doesn't explicitly differentiate from RebootInstances or DeleteInstances, which are also instance management tools.
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 implied usage context ('适用于需要同时管理和停止多台ECS实例的场景' - suitable for scenarios requiring simultaneous management and stopping of multiple ECS instances), suggesting batch operations. However, it doesn't explicitly state when to use this versus alternatives like RebootInstances or DeleteInstances, nor does it mention prerequisites 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 full burden. It mentions batch stopping but doesn't disclose critical behavioral traits: whether this is destructive (likely yes, but not stated), what permissions are required, whether instances can be restarted afterward, if there are rate limits, or what happens to associated resources. For a mutation tool with zero annotation coverage, 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 a single, efficient sentence that communicates the core purpose and usage context without unnecessary words. It's appropriately sized for a tool with 2 parameters and clear functionality, though it could be slightly more front-loaded with the primary action.
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 this is a destructive mutation tool (stopping cloud instances) with no annotations and no output schema, the description is incomplete. It should address safety considerations, permissions, what the tool returns, and error conditions. The current description leaves too many behavioral questions unanswered for a tool that modifies production infrastructure.
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 description coverage is 100%, so the schema already documents both parameters (InstanceIds and RegionId). The description doesn't add any parameter-specific information beyond what's in the schema. With high schema coverage, the baseline is 3 even without additional param details in the description.
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 the action ('批量停止' - batch stop) and resource ('RDS实例' - RDS instances), making the purpose evident. It distinguishes from individual stop operations by emphasizing batch capability, though it doesn't explicitly differentiate from sibling 'StopInstances' which stops ECS instances rather than RDS instances.
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 some usage context ('适用于需要同时管理和停止多台RDS实例的场景' - suitable for scenarios requiring simultaneous management and stopping of multiple RDS instances), which implies when to use it (batch operations). However, it doesn't explicitly state when NOT to use it or mention alternatives like 'StopInstances' for ECS instances or individual RDS instance stopping methods.
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 full burden. It discloses key behavioral traits: it's a destructive operation (deletes/releases instances), supports batch processing (1-100 instances), and mentions cloud disk handling options. However, it lacks details on permissions needed, rate limits, error handling, or confirmation prompts. The description adds value but isn't comprehensive for a high-risk 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 a single, dense sentence that efficiently covers the tool's core functionality and key parameter capability. It's front-loaded with the main purpose and avoids redundancy. However, it could be more structured (e.g., separating usage notes) and slightly verbose in phrasing.
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?
Given high schema coverage (100%) but no annotations or output schema, the description is moderately complete. It identifies the tool as a destructive batch operation and hints at parameter-driven disk handling, but lacks critical context like required permissions, idempotency (though in schema), return values, or error scenarios. For a complex, high-stakes mutation tool, this is adequate but has clear gaps.
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 description coverage is 100%, so parameters are well-documented in the schema. The description adds minimal semantic context by mentioning '支持通过参数设置决定云盘是否释放或转换为按量付费保留' (supports parameter settings to decide whether cloud disks are released or converted to pay-as-you-go retention), which loosely relates to parameters like 'Force' or 'TerminateSubscription'. This provides slight value beyond the schema, warranting a baseline score.
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 the tool's purpose: '批量删除或者释放按量付费实例或者到期的包年包月实例' (batch delete or release pay-as-you-go instances or expired subscription instances). It specifies the verb ('delete/release') and resource ('instances'), but doesn't explicitly differentiate from sibling tools like 'StopInstances' or 'RebootInstances' beyond the destructive nature implied by '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?
No explicit guidance on when to use this tool versus alternatives is provided. The description mentions it handles specific instance types (pay-as-you-go, expired subscription) but doesn't clarify prerequisites (e.g., instance state), compare to tools like 'StopInstances' for temporary halts, or warn about irreversible deletion. Usage context is implied but not structured.
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 behavioral disclosure. While it indicates this is a query/read operation (implied by '查询'), it doesn't address important behavioral aspects like: whether this requires specific permissions, rate limits, pagination behavior, error conditions, or what the response format looks like. For a complex 16-parameter tool with no annotation coverage, this is a significant gap in behavioral transparency.
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 appropriately concise - just two sentences that directly state the purpose and usage context. It's front-loaded with the core purpose and wastes no words. However, it could be slightly more structured by separating the purpose from usage guidance more clearly.
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 tool's complexity (16 parameters, no annotations, no output schema), the description is insufficiently complete. It doesn't explain what 'resource inventory status' means in practical terms, what the output looks like, how to interpret results, or any limitations/constraints of the query. For a tool that presumably returns availability/capacity information critical for provisioning decisions, more context about the nature and format of results would be essential.
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 description coverage is 100%, so the schema already documents all 16 parameters thoroughly with descriptions, examples, and constraints. The description doesn't add any meaningful parameter semantics beyond what's in the schema - it doesn't explain parameter relationships, provide usage examples, or clarify complex dependencies. With complete schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't need to given the comprehensive 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 clearly states the tool's purpose: '查询可用区的资源库存状态' (query resource inventory status in availability zones). It specifies the verb ('查询' - query) and resource ('资源库存状态' - resource inventory status), and mentions two specific use cases (creating instances or modifying instance specs). However, it doesn't explicitly differentiate from sibling tools like DescribeZones or DescribeRegions that might provide related but different information.
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 good context about when to use this tool: '您可以在某一可用区创建实例（RunInstances）或者修改实例规格（ModifyInstanceSpec）时查询该可用区的资源库存状态' (You can query resource inventory status when creating instances or modifying instance specs in an availability zone). This gives clear situational guidance. However, it doesn't explicitly state when NOT to use it or mention alternative tools for similar purposes.
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 full burden and adds crucial behavioral context: it explicitly warns that the operation will restart ECS instances ('本操作将会重启ECS实例'). This discloses a significant side effect not evident from the input schema alone, though it could further detail authentication needs or rate limits.
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 with just two clauses: the core purpose and a critical warning. Every word earns its place, and the warning is front-loaded after the main action, making it immediately noticeable without unnecessary elaboration.
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 mutation tool with no annotations and no output schema, the description is minimally complete: it states the purpose and a key behavioral trait (restart). However, it lacks details on permissions, error handling, or return values, leaving gaps given the tool's destructive nature and complexity.
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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description doesn't add any parameter-specific semantics beyond what's in the schema, maintaining the baseline score of 3 for adequate but no extra value.
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 specific action ('批量修改ECS实例的密码' - batch modify ECS instance passwords) and resource ('ECS实例' - ECS instances). It distinguishes from siblings like 'RebootInstances' by specifying password reset as the primary purpose, not just restarting.
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 through the warning about instance restart, suggesting this tool should be used when password changes are needed despite downtime. However, it doesn't explicitly state when to use this vs alternatives like 'RunCommand' for remote password changes or 'RebootInstances' for just restarting without password modification.
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:

[![alibaba-cloud-ops-mcp-server MCP server](https://glama.ai/mcp/servers/aliyun/alibaba-cloud-ops-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/aliyun/alibaba-cloud-ops-mcp-server)

Score Badge

Copy to your README.md:

[![alibaba-cloud-ops-mcp-server MCP server](https://glama.ai/mcp/servers/aliyun/alibaba-cloud-ops-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/aliyun/alibaba-cloud-ops-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/aliyun/alibaba-cloud-ops-mcp-server'

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