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

Without annotations, the description must disclose behavioral traits. It only indicates that tags are added (mutation) but omits details like idempotency, overwrite behavior, tag limits, or authentication requirements.

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

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

The description is very short and includes a structured Args/Returns section, which helps readability. However, it is too concise to be informative, missing necessary details that would justify its brevity.

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

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

Given the tool has a nested parameter (tags) and no annotations or output schema, the description fails to provide sufficient context about input format, preconditions, or what the response contains. It is incomplete for effective use.

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

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

The parameter descriptions are minimal, essentially restating the parameter names with slight elaboration (e.g., 'The region ID of the RDS instance.'). No details on the structure of the tags object or value constraints are provided, and the schema has no descriptions.

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

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

The description clearly states the tool adds tags to a DB instance, which is a specific verb+resource. It distinguishes from sibling tools that focus on creation, modification, or description. However, it lacks any further context about what adding tags entails.

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

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

No guidance is provided on when to use this tool versus alternatives, such as when the instance exists or if tags should be replaced. There is no mention of prerequisites or exclusion criteria.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states 'allocate' without disclosing side effects, authentication requirements, rate limits, or whether the operation is idempotent. The description is insufficient for safe use.

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

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

The description is concise but uses a Python docstring format with Args and Returns, which is not standard for MCP descriptions. It is adequate but could be more streamlined.

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

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

Given no output schema, no annotations, and 4 parameters, the description is incomplete. It fails to explain what 'allocate' entails, the format of the return dict, or any constraints like region availability.

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

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

Schema coverage is 0%, meaning no property descriptions. The description mentions three of four parameters (region_id, db_instance_id, connection_string_prefix) but adds no meaning beyond their names. The port parameter is omitted entirely.

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

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

The description clearly states 'allocate db instance public connection,' providing a specific verb and resource. However, it does not differentiate from sibling tools like attach_whitelist_template_to_instance or modify_security_ips, which also deal with connectivity.

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

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

No guidance on when to use this tool versus alternatives. It does not mention prerequisites, such as whether the instance must not already have a public connection, or when to avoid using it.

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

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

No annotations provided. The description does not disclose behavioral traits (e.g., permissions, side effects, idempotency). The mismatch between description and name creates confusion, not transparency.

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

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

The description is short but the main sentence is inaccurate and misleading. Conciseness is undermined by incorrect content.

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

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

No output schema, no error handling information, no examples. The parameter explanations are minimal. The core action is misrepresented, making the tool contextually incomplete.

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

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

Despite 0% schema description coverage, the description provides brief explanations for all three parameters (e.g., 'region_id: The region ID of the RDS instance'), adding meaning beyond the schema's property names and types.

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

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

The description states 'allocate db instance public connection' which contradicts the tool name 'attach_whitelist_template_to_instance'. This is misleading and does not clarify the actual purpose.

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

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

No guidance on when to use this tool vs siblings like 'allocate_instance_public_connection' or 'describe_all_whitelist_template'. Agent has no context for selection.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It mentions 'Create' implying mutation and includes a client_token for idempotency, but does not discuss permissions, asynchronous behavior, or side effects beyond creation. This is insufficient for a complex provisioning tool.

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

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

The description follows a standard docstring format with Args and Returns sections. It is systematic but verbose due to listing all parameters. The first line directly states the purpose, which is good, but the bulk could be trimmed or organized more efficiently.

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

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

All parameters are covered, and there are hints about prerequisites (e.g., VPC, VSwitch are required). However, preconditions like existing network resources are not explicitly stated, and the return value is merely 'Dict[str, Any]' without detail. Given the tool's complexity, more completeness is needed.

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

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

The description adds meaning to all 27 parameters beyond the schema's bare type/name/default (since schema description coverage is 0%). It provides brief descriptions, defaults, and references to sibling tools for queries (e.g., 'Query available class_codes by describe_available_classes'). Some descriptions are terse but still valuable.

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

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

The description starts with 'Create an RDS instance,' which clearly states the tool's verb and resource. The sibling tools are primarily describe and modify operations, so this creation tool is distinct and well-positioned.

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

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

The description does not explicitly state when to use this tool versus alternatives. It indirectly references sibling tools (describe_available_classes, describe_available_zones) in parameter descriptions, but lacks direct guidance on when to create vs. describe or modify.

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

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

No annotations are provided, so the description carries the full burden. It only states 'Create a new account,' implying a mutation, but does not disclose side effects, required permissions, reversibility, error conditions, or any other behavioral traits.

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

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

The description is somewhat verbose with a repetitive list of parameters that largely mirrors the schema. The first sentence is concise, but the list could be streamlined or omitted if the schema provides adequate documentation.

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

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

Given 0% schema description coverage and no output schema, the description is incomplete. It does not explain the return value behavior (just says 'The response'), error handling, or prerequisites. Sibling tools like describe_db_instance_accounts exist but are not mentioned for guidance.

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

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

The description lists parameters with phrases like 'The region ID of the RDS instance,' which merely restates the parameter name. With 0% schema description coverage, the description should add format, constraints, or examples, but it adds minimal semantic value beyond the schema's field names.

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

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

The description starts with 'Create a new account for an RDS instance,' clearly stating the verb 'create' and the resource 'account for RDS instance.' However, it does not differentiate from sibling tools that also create resources (e.g., create_db_instance), but given the distinct resource type, it is clear enough.

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

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

No guidance is provided on when to use this tool vs. alternatives, such as when to create an account versus modifying security settings or describing accounts. The description lacks context for selection.

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

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

Annotations already declare readOnlyHint=true, so the description's return type adds minimal value. No mention of potential pagination, rate limits, or empty results. The read-only behavior is adequately communicated by annotations.

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

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

The description is short and front-loaded with purpose. It efficiently lists parameters and return type. Minor grammar issues ('whitelist template' vs 'whitelist templates') do not significantly detract.

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

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

Given the tool's simplicity (2 params, read-only) and an output schema existing, the description covers basic functionality. However, it lacks guidance on usage and has a parameter description error, which reduces completeness for an agent.

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

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

The description provides one-line explanations for both parameters, adding some meaning beyond schema titles. However, the description for template_name ('The ID of the RDS instance') is likely incorrect (it should be template name), potentially misleading. With 0% schema coverage, the description carries burden but does so inaccurately.

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

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

The description states 'describe all whitelist template' with parameters for region and optional template name, making the purpose clear. It differentiates from sibling tools like describe_instance_linked_whitelist_template by focusing on templates themselves. However, wording is slightly awkward and could specify that omitting template_name returns all templates.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., describe_instance_linked_whitelist_template). The description does not indicate typical use cases or that template_name is optional, leaving the agent to infer from names.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Query' aligns with that. The description adds context by specifying the return type and parameter roles, but does not elaborate on potential side effects or rate limits, which is acceptable for a read-only tool.

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

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

The description is well-structured with Args and Returns sections and is front-loaded with the purpose. While concise overall, it could be slightly shortened without losing clarity, but every sentence is informative.

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

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

Given the tool's complexity (10 parameters, 7 required) and lack of output schema, the description covers all parameters and mentions the return type (Dict[str, Any]) and content (instance classes and storage ranges). It is sufficiently complete for a query tool.

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

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

With 0% schema description coverage, the description fully compensates by listing each parameter, its purpose, and acceptable values (e.g., engine: MySQL, SQLServer, etc.). This adds critical meaning beyond the raw schema types.

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

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

The description clearly states the tool 'Query the RDS instance class_code and storage space that can be purchased in the inventory', providing a specific verb and resource. It distinguishes itself from siblings like describe_available_zones by focusing on class_code and storage, not zones.

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

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

The description implicitly indicates usage when needing available instance classes and storage, and mentions a related tool (describe_available_zones) for zone queries. However, it lacks explicit when-not-to-use or alternative tools for other scenarios.

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

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

The readOnlyHint annotation already indicates no side effects. The description adds some behavioral context through parameter options (e.g., dispense_mode, category) but does not disclose potential rate limits, authentication needs, or return format details beyond 'Dict[str, Any].'

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

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

The description is well-structured with an Args list and Returns section, making it easy to scan. However, it is somewhat verbose, particularly the full lists of engine versions and commodity codes, which could be abbreviated.

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

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

Given the tool has 8 parameters with no schema descriptions and an output schema exists (though not shown), the description provides essential parameter semantics and a return type hint. It lacks details on error handling, pagination, or limits, but for a read-only zone query, it is reasonably complete.

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

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

With 0% schema description coverage, the description compensates fully by enumerating allowed values for engine_version, commodity_code, dispense_mode, category, and explaining the purpose of each parameter, including defaults and dependencies (e.g., dbinstance_name required for read-only instances).

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

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

The description clearly states 'Query available zones for RDS instances,' specifying the verb and resource. However, it does not explicitly differentiate from sibling tools like 'describe_available_classes,' which serves a similar query purpose for instance classes.

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

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

The description implies usage for checking available zones when configuring RDS instances through the parameter list, but it lacks explicit guidance on when to use this tool versus alternatives, nor does it state prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, so the description is consistent and adds no contradictory info. It describes the query operation but does not disclose additional behavioral traits like data freshness, rate limits, or permission requirements. With annotations covering safety, the description's lack of extra detail is acceptable.

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

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

The description is concise, with a clear purpose statement followed by parameter explanations. It could be more structured (e.g., bullet points or separate sections), but it is efficient and front-loaded.

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

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

The description covers the function and parameters adequately. Since an output schema exists, the vague return description ('str: billing information') is acceptable. However, it lacks context about the scope (e.g., what user, how billing periods are determined) and does not mention any prerequisites or error conditions.

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

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

Schema description coverage is 0%, so the description must compensate. It provides examples and explanations for billing_cycles ('YYYY-MM'), db_instance_id (example 'rm-xxx'), and is_billing_item (boolean indicating dimension). This adds significant meaning beyond the schema, which only has titles.

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

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

The description clearly states it queries consumption summary for a user within a billing period. It specifies the resource (product instances/billing items) and the action (query). It distinguishes from sibling describe_* tools by focusing on billing, though it could be more precise about what 'consumption summary' includes.

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

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

No guidance is provided on when to use this tool versus alternatives. Sibling tools like describe_db_instances or describe_monitor_metrics are not mentioned, and there are no conditions for when not to use this tool. The agent must infer usage from the name alone.

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

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

Annotations already provide readOnlyHint=true, so the description adds only the batch nature and arg explanations. No additional behavioral traits (e.g., pagination, limits) are disclosed, but the read-only status is covered.

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

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

The description is very concise—one line for purpose followed by structured Args and Returns. No extraneous text, front-loaded, each element earns its place.

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

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

Given the simple tool (2 params, no nested objects) and existing annotations, the description covers purpose, args with examples, and return type. It omits potential limits on batch size but is largely complete for typical use.

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

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

Despite 0% schema coverage, the description explains both parameters with specific examples: 'region_id' as region ID and 'db_instance_ids' with example values. This adds significant meaning beyond the schema's type-only definitions.

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

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

The description clearly states it 'Batch retrieves account information for multiple RDS instances,' specifying the verb (retrieve), resource (account information), and scope (multiple instances). This distinguishes it from siblings like describe_db_instance_databases or describe_db_instance_parameters.

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

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

The description implies use when needing account info for multiple instances but offers no explicit guidance on when to use this tool versus alternatives like describe_db_instance or other tools. No when-not-to-use or exclusion criteria.

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

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

The annotation readOnlyHint=true already indicates a safe read operation. The description adds 'queries' which aligns, but no additional behavioral traits (e.g., rate limits, auth needs) are disclosed. The annotation carries the burden, so a 3 is appropriate.

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

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

The description is short and to the point, using two sentences plus structured args. It is front-loaded with the main purpose. No unnecessary verbiage, though the formatting could be more standardized.

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

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

Given no output schema, the description lacks explanation of return values. It also does not differentiate from closely related tools like describe_db_instance_performance. The tool is simple, so a 3 is adequate but leaves gaps.

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

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

Schema coverage is 0% with no parameter descriptions in the JSON schema. The description provides example values (e.g., 'cn-hangzhou', 'rm-xxx'), adding meaning beyond the bare schema. This compensates for the missing schema descriptions.

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

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

The description clearly states 'Queries the details of an instance,' which conveys a specific verb and resource. It distinguishes from siblings like describe_db_instances (likely lists) and describe_db_instance_performance (performance metrics).

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

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

No guidance on when to use this tool vs alternatives. It does not mention that it is a detailed query for a single instance, nor does it exclude scenarios where other tools like describe_db_instances or describe_db_instance_performance might be more appropriate.

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

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

The description adds context beyond annotations by noting it operates in batch and returns a list of dicts. However, with readOnlyHint already present, it adds limited behavioral detail such as performance implications or response structure.

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

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

The description is extremely concise: a single sentence for purpose, then straightforward parameter definitions. Every piece of text is valuable and front-loaded.

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

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

Given the tool's simplicity (2 required parameters, output schema exists), the description provides enough context. It explains the batch nature, parameters, and return format, though it could briefly note that details are in the output schema.

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

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

With 0% schema coverage, the description significantly adds meaning by specifying region_id as the region ID and providing an example for db_instance_ids. This compensates for the lack of schema descriptions.

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

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

The description clearly states the tool performs a batch retrieval of database information for multiple RDS instances, using specific verbs and resource. It distinguishes itself from sibling tools like describe_db_instances by focusing on databases within instances.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., describe_db_instances for instance metadata). It only states what it does, 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.

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

The description adds 'batch' capability beyond the readOnlyHint annotation, which is valuable for an AI agent. However, it lacks details on potential limits, error behavior, or pagination. The annotation reduces the burden, making this score appropriate.

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

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

The description is concise and well-structured with Args and Returns, but it could include more context without being verbose. No unnecessary content.

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

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

The description covers the basic purpose and parameters, and an output schema exists. However, it omits details about the return structure content or potential pagination, leaving gaps for an agent to fully understand the tool's behavior.

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

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

With 0% schema coverage, the description provides minimal parameter meaning: region_id as region ID and db_instance_ids with an example. This adds some value but lacks constraints or accepted formats. Baseline 3 is warranted.

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

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

The description clearly states the tool performs a batch retrieval of IP allowlist configurations for multiple RDS instances, using specific verbs and resources. It distinguishes itself from sibling tools like describe_db_instance_net_info or modify_security_ips.

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

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

The description implies the tool is for reading IP allowlists but does not explicitly state when to use it versus alternatives like describe_db_instance_net_info or modify_security_ips. No exclusion criteria or prerequisites are provided.

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

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

The description is consistent with the readOnlyHint annotation (read-only retrieval). It adds the batch behavior but no further behavioral details beyond what annotations already convey. It does not contradict annotations.

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

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

The description is extremely concise, with a single-purpose sentence followed by structured Args and Returns sections. Every word adds value, and the most important action is front-loaded.

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

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

Given the tool's simplicity and the presence of an output schema, the description provides sufficient information about inputs and outputs. It lacks edge cases or prerequisites but is functionally complete for typical use.

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

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

With 0% schema coverage, the description compensates by explaining the purpose of each parameter and providing an example for db_instance_ids. This adds meaningful context beyond the schema types.

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

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

The description clearly states the verb 'retrieves' and the resource 'network configuration details for multiple RDS instances', which is specific and distinguishes it from sibling tools that describe other aspects like attributes or databases.

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

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

The description does not provide any guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. It only states the tool's function.

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

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

Annotations already declare readOnlyHint=true, aligning with the description's 'retrieves' verb. The description adds context that it operates in batch mode and returns a list of dictionaries, but does not disclose other behavioral traits like rate limits or pagination.

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

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

The description is a concise docstring with Args and Returns sections, providing necessary information without extra fluff. The structure is clear, though the typo slightly detracts.

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

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

Given the tool's complexity (3 parameters, batch operation, output schema exists but not provided), the description covers the return structure and main parameters. It lacks details on error handling or edge cases, but is sufficient for basic usage.

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

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

Schema description coverage is 0%, so the description compensates by explaining each parameter: region_id, db_instance_ids (list of identifiers), and paramters (list of parameter names with examples). The return type and structure are also described. A minor typo ('paramters' instead of 'parameters') slightly reduces clarity.

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

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

The description clearly states 'Batch retrieves parameter information for multiple RDS instances,' specifying the verb 'retrieves,' the resource 'parameter information,' and the context of batch operation. This distinguishes it from other describe tools that focus on single instances or different attributes.

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

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

The description does not provide guidance on when to use this tool versus alternatives, such as when to use describe_db_instances or other describe tools. No exclusions or context for appropriate usage are given.

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

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

Annotations (readOnlyHint=true) cover the read-only nature. The description adds value by listing example performance metrics (MemCpuUsage, QPSTPS, etc.) that the tool returns. However, it does not disclose other behavioral traits like rate limits or pagination.

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

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

The description is concise: one sentence for purpose followed by a clear bullet list of parameters with examples. No unnecessary words, well-structured for quick parsing.

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

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

Given the tool has 6 required parameters and no output schema, the description covers purpose and parameters but lacks information about the return format (e.g., whether it returns a list or object). The mention of metrics is helpful but incomplete without output structure.

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

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

Schema coverage is 0%, so the description must compensate. It provides example values for each parameter (e.g., region_id: cn-hangzhou, perf_keys: array of strings), adding meaning beyond the schema titles. However, format details like date-time format for start_time/end_time are not explicitly specified.

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

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

The description clearly states the tool queries performance data from RDS, with a specific verb ('Queries') and resource ('instance'). It distinguishes from siblings like describe_db_instance_attribute by focusing on performance metrics, but does not explicitly contrast.

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

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

No guidance on when to use this tool versus alternatives like describe_db_instance_attribute or describe_slow_log_records. The description implies use for performance monitoring but lacks explicit context or exclusions.

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

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

The annotation readOnlyHint=true is consistent with the description 'Queries.' However, no additional behavioral details such as result format, pagination, or side effects are disclosed.

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

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

The description is very short but lacks key information. It is concise but at the expense of completeness.

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

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

Given the simplicity and single parameter, the description is incomplete. It does not explain what 'instances' are, what the response contains, or any usage constraints (e.g., required permissions).

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

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

Schema description coverage is 0%, placing the burden on the description. The description merely repeats 'region_id' without adding meaning beyond the schema's title 'Region Id'. No example or format is given.

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

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

The description states 'Queries instances.' which is clear about the verb and resource, but does not distinguish from sibling tools like describe_db_instance_attribute. The region_id parameter is mentioned.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites or exclusions.

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

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

Annotations already indicate readOnlyHint=true, so the tool is known to be safe. The description adds parameter format details but doesn't disclose additional behavioral traits beyond the schema.

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

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

The description is structured with 'Args:' and 'Returns:' sections, clearly listing parameters. It is efficient without fluff, though not extremely front-loaded.

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

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

Given the presence of an output schema, the return type note is sufficient. The description covers required parameters, pagination, and time format, making it complete for the tool's complexity.

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

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

With 0% schema description coverage, the description carries full burden. It explains all 6 parameters, including format for start_time and end_time, and range for page_size, which adds value beyond the schema.

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

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

The description clearly states 'Query error logs of an RDS instance,' specifying the verb and resource. It distinguishes itself from sibling tools like describe_slow_log_records and describe_db_instance_performance.

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

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

No guidance on when to use this tool vs alternatives like describe_slow_log_records. The description lacks context on 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.

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

The description adds no behavioral details beyond what the 'readOnlyHint' annotation already conveys. It does not mention any side effects, authentication requirements, performance implications, or limitations such as the scope of the template.

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

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

The description is minimal but lacks substance. Conciseness is achieved at the expense of utility, with no meaningful information beyond a placeholder structure.

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

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

Given no output schema and no parameter descriptions, the tool is completely underspecified. The agent cannot determine what the tool does or what a successful response looks like.

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

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

Schema description coverage is 0%, and the description only lists the parameter names ('region_id', 'db_instance_id') without explaining their purpose, valid values, or format. The agent cannot infer what these parameters mean.

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

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

The description merely restates the tool name as 'describe instance linked whitelist template' without clarifying what a whitelist template is or what specific information is returned. This is a tautology, as it uses the same words as the name.

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

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

No guidance is provided on when to use this tool versus sibling tools like 'describe_all_whitelist_template' or 'attach_whitelist_template_to_instance'. There is no context for appropriate usage.

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

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

Annotations already indicate readOnlyHint=true, and the description adds that it uses the DAS API and provides extra diagnostic data. No contradictions, but no additional behavioral traits like rate limits or data freshness are mentioned.

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

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

The description is well-structured with a clear first sentence followed by a parameter list with examples. Every sentence adds value without redundancy.

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

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

Despite having 5 required parameters and no output schema, the description only returns a vague statement 'the monitor metrics information' without specifying structure, format, or possible values. This is insufficient for an agent to understand what the tool returns.

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

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

All 5 parameters are described with examples (e.g., date format for start_time, typical metrics for metrics_list, database type for db_type). Since schema description coverage is 0%, the description fully compensates by providing meaningful usage guidance.

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

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

The description clearly states it queries performance metrics using the DAS API and explicitly contrasts with sibling tool 'describe_db_instance_performance', listing specific metrics like IOPSUsage and MdlLockSession that this tool can retrieve.

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

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

The description explicitly mentions that this tool provides data not available from describe_db_instance_performance, giving clear context for when to use it. However, it does not provide explicit when-not-to-use or other alternative guidance.

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

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

Annotations indicate readOnlyHint: true, so no destructive behavior. The description adds valuable behavioral context: time constraints (start_time cannot be earlier than 30 days ago), node_id applicability only to cluster instances, and pagination details. It does not mention what happens with no results or rate limits, but these are less critical given the 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.

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

The description is well-structured with Args and Returns sections. Each sentence adds value; no redundancy. The purpose is front-loaded, and parameter details are organized in a readable list. It is appropriately sized for the tool's complexity.

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

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

Given 9 parameters (4 required), an output schema exists, so the description need not detail return fields. It covers all parameters, includes constraints, and provides context for cluster instances. A minor gap is the lack of explanation on interpreting the returned records, but overall it is thorough.

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

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

Schema description coverage is 0%, so the description fully compensates by detailing each parameter. It explains time format, value ranges, defaults, and usage context for optional parameters like sqlhash and node_id. This is essential for correct usage and significantly surpasses what the schema alone provides.

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

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

The description clearly states the tool's purpose: 'Query slow log records for an RDS instance.' It identifies the specific resource (RDS instance) and the action (query slow logs), distinguishing it from sibling tools like describe_error_logs or describe_db_instances.

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

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

The description provides parameter constraints but lacks explicit guidance on when to use this tool versus alternatives. No mention of when to prefer describe_slow_log_records over other describe_* tools. The description is self-contained but does not aid in tool selection among siblings.

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

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

Annotations provide 'readOnlyHint=true', which is consistent with the description's 'Query' nature. The description adds the return format (CSV) but lacks details on error handling, rate limits, or behavioral traits like data freshness or date range restrictions.

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

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

The description is concise, front-loading the purpose and providing parameter details in a docstring-like format. No redundant sentences; however, the 'Args:' style is slightly informal for a JSON-based environment.

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

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

Given the tool's simplicity (3 required string parameters, read-only, CSV output), the description provides sufficient context. The output schema exists to detail return fields, so the description need not elaborate. It covers purpose and parameters adequately.

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

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

With 0% schema description coverage, the description compensates well by explaining 'dbinstance_id' as the RDS instance ID and providing format examples for 'start_time' and 'end_time' (e.g., '2025-06-06 20:00:00'). This adds meaning beyond the schema's titles.

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

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

The description clearly states it queries SQL log statistics including cost time, execution times, and account, using the verb 'Query'. While it distinguishes itself from siblings like 'describe_db_instance_performance' and 'describe_slow_log_records' by focusing on 'SQL insight statistic', it could be more explicit about how it differs.

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

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

No guidance on when to use this tool versus alternatives like 'describe_slow_log_records' or 'query_sql'. The description does not mention prerequisites, constraints, or when not to use it, lacking explicit usage context.

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

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

Annotations indicate readOnlyHint=true, which aligns with 'Query.' The description adds default values for page_number and page_size, and notes that vpc_id can accept up to 20 IDs separated by commas, which is behavioral context beyond the schema.

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

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

The description is front-loaded with the purpose and then lists parameters in a structured docstring format. It is slightly verbose but clear and well-organized, earning its place.

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

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

Given the output schema exists, the return value description ('Dict[str, Any]') is sufficient. All parameters are covered, pagination is explained, and the tool is a simple read-only list query. No gaps detected.

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

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

Schema coverage is 0%, so the description carries the full burden. It provides meaningful descriptions for all 8 parameters, including defaults and constraints (e.g., 'Up to 20 VPC IDs,' 'Maximum value: 50' for page_size), significantly aiding parameter understanding.

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

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

The description starts with 'Query VPC list,' clearly indicating the verb and resource. The parameter list details specific filters (region_id, vpc_id, etc.), distinguishing it from sibling tools like describe_vswitches, which are about subnets, not VPCs.

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

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

No guidance is provided on when to use this tool vs alternatives. There is no mention of alternative tools like describe_vswitches or when to use this instead of other listing tools. The description only explains parameters.

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

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

Annotations already declare readOnlyHint=true. The description adds value by detailing pagination parameters (page_number, page_size) and required parameter constraints, disclosing behavior beyond the annotations.

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

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

The description is well-structured with Args and Returns sections, and the key action is front-loaded. It is slightly verbose due to the parameter list, but remains clear and effective.

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

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

The description covers all necessary aspects: purpose, parameters with constraints, pagination, and return type. With an output schema present, the return description is sufficient. Complete for a read-only list tool.

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

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

The description explains the purpose of 8 out of 9 parameters (all except is_default), including constraints like 'At least one of region_id or vpc_id must be specified.' This adds significant meaning beyond the schema's titles and defaults.

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

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

The description starts with 'Query VSwitch list,' providing a specific verb and resource. Listing parameters unique to VSwitches distinguishes it from sibling tools like describe_db_instances or describe_vpcs.

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

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

The description states that at least one of region_id or vpc_id must be specified, which is a usage hint. However, it does not compare to other tools or explain when to prefer this tool over alternatives.

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

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

The annotation readOnlyHint=true already indicates no mutation, but the description adds no further behavioral context (e.g., no mention of error handling, performance impact, or interpretation of the plan).

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

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

Description is short and includes structured Args/Returns, making it easy to parse. It wastes no words, though the Returns section could be more concise.

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

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

The tool returns an execute plan, but the description does not elaborate on its format or interpretation. Given that an output schema exists (not shown), the description is sparse and lacks sufficient context for understanding the result.

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

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

Schema coverage is 0%, so the description carries full burden. The docstring style 'Args' section provides basic explanations ('The ID of the RDS instance') that add minimal value beyond the parameter names, but do not fully compensate for the missing schema descriptions.

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

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

Description clearly states 'show sql execute plan', which is a specific verb+resource combination. It distinguishes from siblings like query_sql (runs queries) and show_create_table (shows table schema).

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

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

No guidance on when to use this tool versus alternatives such as query_sql or describe_slow_log_records. The description does not provide context for selection.

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

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

Annotations declare readOnlyHint=true, so the agent knows it's safe. The description adds that it returns a dict with current time, but no details on timezone, precision, or side effects. Adequate but not rich.

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

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

Extremely concise: one sentence plus return type annotation. No wasted words, front-loaded with purpose.

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

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

For a simple zero-parameter tool, it is mostly complete. However, the lack of an output schema means the agent has no details on the dictionary structure (e.g., keys, time format). Adequate but could be improved.

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

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

No parameters, schema coverage is 100%. The description adds value by specifying the return type (Dict) and content ('current time'), which is beyond the empty schema.

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

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

The description clearly states 'Get the current time' with a specific verb and resource. It is distinct from sibling tools which are all database-related operations.

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

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

No explicit guidance on when to use this tool vs alternatives, but the purpose is self-explanatory and alternatives are all database operations. Lack of context on timezone or format is a minor gap.

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

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

The description does not disclose any behavioral traits such as destructive nature, required permissions, or side effects. With no annotations, the description fails to inform the agent about the operation's implications.

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

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

The description is short and follows a docstring format, but it includes redundant elements (e.g., 'Returns: dict[str, Any]') that add no value. It is concise but not optimally structured for AI consumption.

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

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

With no output schema, no annotations, and incomplete parameter explanations, the description lacks completeness. It does not explain what the modification entails or what the response contains.

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

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

The description repeats the parameter names with minimal context (e.g., 'region_id: The region ID'). Schema description coverage is 0%, and the description adds no meaningful semantics beyond what the parameter names already convey.

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

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

The description clearly states that the tool modifies a DB instance description, which distinguishes it from sibling tools like 'modify_db_instance_spec' or 'modify_parameter'. However, it lacks explicit differentiation or scope clarification.

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

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

No guidance is provided on when to use this tool versus alternatives. There are no when-to-use, when-not-to-use, or prerequisite conditions mentioned.

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

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

No annotations provided, so description carries full burden. It only says 'modify' but does not disclose side effects like potential downtime, restart, or data loss. Behavioral traits such as destructive nature are not addressed.

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

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

One-line purpose followed by a structured parameter list. No extraneous text. Efficient and front-loaded, though the list is long due to 20 parameters.

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

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

With output schema present, return description is minimal but acceptable. However, the description does not explain constraints like whether storage can only be increased, or which parameter combinations are invalid. Overall adequate but with gaps.

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

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

Schema description coverage is 0%, so description must add meaning. It provides brief explanations for each parameter (e.g., 'pay_type: Instance payment type. Values: Postpaid, Prepaid, Serverless.'), but some (e.g., 'zone_id: Zone ID') are vague. Adds some value but not comprehensive.

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

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

The description starts with 'Modify RDS instance specifications,' which clearly states the verb and resource. It distinguishes from sibling tools like create_db_instance (creating) and describe_db_instances (reading).

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites or conditions. For example, it doesn't mention that the RDS instance must exist or must be in a specific state.

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

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

No annotations are provided, so the description must carry the burden. It includes behavioral details like forcerestart and switch_time_mode, but does not disclose permissions, rate limits, or side effects beyond what is implied by parameters. It is adequate but not comprehensive.

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

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

The description is well-structured with a clear one-line purpose, then systematic parameter documentation. Every sentence adds value, and it is front-loaded. Efficient use of space.

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

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

Given the complexity (8 parameters, nested object, no annotations) and presence of output schema, the description covers all parameters and return value. It is complete for an API tool, explaining all inputs and expected output.

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

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

Schema description coverage is 0%, but the description fully compensates. It details all 8 parameters with types, examples, defaults, and constraints (e.g., max 64 characters for client_token). Adds significant meaning beyond the schema.

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

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

The description states 'Modify RDS instance parameters' with a specific verb and resource. It clearly distinguishes from sibling tools like modify_db_instance_spec, which modifies instance specs rather than parameters.

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

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

The description provides clear context that the tool modifies parameters, but does not explicitly state when to use it versus alternatives or when not to use it. No exclusions or prerequisites are mentioned.

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

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

No annotations provided; description lacks details on side effects (e.g., replacement vs. append), required permissions, or idempotency behavior beyond mentioning client_token.

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

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

The description is structured with an Args block and return type, front-loaded with the purpose, but contains some verbosity in parameter listing.

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

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

All parameters are explained, but the description lacks overall operational context (e.g., whether IPs are replaced or appended, error scenarios) and the return type is minimal despite an existing output schema.

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

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

Schema description coverage is 0%, but the description adds detailed meaning for most parameters, including options for whitelist_network_type and security_ip_type, compensating for the lack of schema descriptions.

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

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

The description clearly states the verb 'modify' and resource 'security ips' for an RDS instance, but does not differentiate from sibling tools like attach_whitelist_template_to_instance or describe_db_instance_ip_allowlist.

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

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

No guidance on when to use this tool versus alternatives, nor any prerequisites or conditions for use.

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

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

Annotations already provide readOnlyHint: true, and the description repeats 'read-only' without adding additional behavioral details such as error handling, timeout, or result size limits. The description adds minimal value beyond annotations.

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

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

The description is concise with two sentences and a parameter list. It front-loads the purpose, and every part contributes meaning. Slightly under-specified for completeness but efficient.

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

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

Given the tool has 4 required parameters and an output schema (not detailed), the description covers core semantics but lacks detail on the output format ('the sql result' is vague). For basic usage it is adequate, but could be more complete.

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

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

Despite 0% schema coverage, the description includes an Args section with brief explanations for each parameter (e.g., 'dbinstance_id: The ID of the RDS instance'), adding meaning beyond the schema titles. However, descriptions are minimal and could be more informative.

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

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

The description explicitly states 'execute read-only sql likes show xxx, select xxx', clearly indicating the tool is for read-only SQL queries. It specifies SQL command types and distinguishes from sibling tools like 'explain_sql' or 'show_create_table'.

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

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

The description implies use for read-only queries but does not provide explicit guidance on when to use this tool versus alternatives like 'explain_sql' or modifications. No exclusions or when-not-to-use are mentioned.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It explains parameters like effective_time and client_token for idempotency, but fails to mention that restarting may disrupt connections or require authorization. The impact of the operation is not conveyed.

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

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

The description is well-structured with a clear parameter list and return type. It is slightly verbose but every sentence adds value. Could be condensed slightly, but it remains efficient.

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

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

For a restart operation, the description covers input parameters and output but omits critical context like potential downtime, required permissions, or related sibling tools for checking instance state. With an output schema present, return value explanation is adequate.

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

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

The description adds significant meaning beyond the schema, which has no docstrings (0% coverage). It explains effective_time options, switch_time format and condition, and client_token purpose. The parameter details are clear and actionable.

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

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

The description clearly states 'Restart an RDS instance.' This is a specific verb+resource combination. Among siblings, no other tool performs restart, so it is well-differentiated.

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

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

The description does not provide any guidance on when to use this tool versus alternatives. It lacks context about prerequisites, such as checking the instance status using describe_db_instances, or when not to restart (e.g., during backups).

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

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

Annotations already declare readOnlyHint=true. The description adds that it returns SQL results, which is consistent. However, no behavioral details are given about error handling or permissions beyond the parameter list.

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

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

The description is short but structured as a docstring with parameter list and return. However, the opening line 'show create table db_name.table_name' may be misinterpreted as usage syntax rather than a purpose statement. Could be more front-loaded.

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

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

Despite an output schema existing, the description provides only basic parameter descriptions and no context on typical usage or integration with sibling tools. The tool has 4 required parameters and needs more complete guidance.

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

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

Schema description coverage is 0%, so the description must compensate. It provides brief explanations for each parameter (e.g., 'the ID of the RDS instance'). While minimal, these add meaning beyond the parameter names.

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

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

The description clearly states the tool shows the CREATE TABLE statement for a given table. The verb 'show' and resource 'create table' are specific, and the purpose is distinct from sibling tools like explain_sql or show_largest_table.

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

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

No guidance is provided on when to use this tool versus alternatives like explain_sql or query_sql. The description simply lists parameters without context for selecting the tool.

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

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

The annotations already indicate readOnlyHint=true, so the description adds minimal behavioral context, only stating 'Returns: the sql result.' This is acceptable given the annotations, but provides no details about the exact output format or any side effects.

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

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

The description is short and to the point, with a clear structure of purpose, arguments, and returns. However, it could be more concise by removing unnecessary labels like 'Args:' and 'Returns:' if the schema already provides structure.

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

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

Given the existence of an output schema, the return value description is less critical. However, the description lacks any contextual guidance, such as typical use cases or relationship to sibling tools, making it minimally complete.

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

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

With 0% schema description coverage, the description must compensate by explaining parameters. It lists both parameters with their types and descriptions, but these descriptions are essentially restatements of the parameter names (e.g., 'The ID of the RDS instance'). This adds minimal meaning beyond the schema.

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

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

The description clearly states the action ('show engine innodb status') and the resource ('in db'), making it easy to understand what the tool does. However, it does not differentiate it from sibling tools that also operate on DB instances, such as 'describe_db_instance_parameters' or 'query_sql'.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, contexts, or exclusions, leaving the agent without information to select the appropriate tool among many database-related siblings.

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

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

Annotations already declare readOnlyHint=true, so the description merely adds 'highest space occupancy' context. No additional behavioral traits (e.g., limitations, side effects) are disclosed beyond the annotation.

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

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

The description is a single, clear sentence with no filler. It is well-front-loaded but could be slightly more informative without becoming verbose.

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

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

Given the presence of an output schema, annotations, and full parameter descriptions, the description is adequate for a straightforward query tool. It covers the essential purpose and context.

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

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

Schema coverage is 100% with each parameter already described. The description adds no extra meaning beyond the schema, meeting the baseline for high coverage.

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

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

The description 'Query the top few tables with the highest space occupancy' uses a specific verb ('Query') and clearly identifies the resource ('tables') and context ('highest space occupancy'). It effectively distinguishes itself from the sibling 'show_largest_table_fragment' which focuses on fragments.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'show_largest_table_fragment' or when not to use it. It lacks explicit context for when-to-use or when-not-to-use.

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

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

Annotations already declare readOnlyHint=true, and the description uses 'Query' which aligns. No additional behavioral traits are disclosed (e.g., performance, permissions). With annotations present, the bar is lower, so a score of 3 is appropriate.

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

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

The description is a single, concise sentence (7 words) that is front-loaded with the action. It earns its place but could benefit from a bit more detail on scope.

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

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

Given the tool's moderate complexity (3 params, output schema exists), the description is minimal. It doesn't elaborate on return values or ordering, but the output schema presumably covers that. Not complete enough for higher score.

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

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

Input schema coverage is 100% with descriptions for all parameters. The description adds no extra meaning beyond the schema (e.g., it doesn't explain how topK relates to fragment size). Baseline 3 is adequate.

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

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

The description 'Query the tables with the largest table fragments' clearly states the action (query) and the target (tables with largest fragments). It is specific, though it does not explicitly differentiate from sibling 'show_largest_table' which may cover overall table sizes.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'show_largest_table' or others. No prerequisites or usage context are given.

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