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

Annotations already indicate readOnlyHint=true and openWorldHint=false. The description adds that it 'runs locally without network access' and crucially states that pricing is 'as of August 2026,' meaning results rely on a static snapshot and could be outdated. This is valuable beyond annotation metadata.

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 three sentences and front-loaded with the main purpose. Each sentence adds necessary information: the estimate scope, execution mode, and pricing caveats/contact link. There is no redundancy or filler.

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

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

For a single-parameter read-only tool, the description covers the plan, pricing tiers, minimums, data source date, execution mode, and custom-pricing path. It does not describe the output format, but since no output schema exists, this omission is not a major deficiency for tool selection and invocation.

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

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

Schema covers the parameter fully with type, description, and example. The description enriches this by explaining how the parameter value maps to progressive tiers ($5/TB down to $2.50/TB) and the $25 minimum covering the first 5 TB, giving the single input meaningful context for how it affects the estimate.

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

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

The description opens with 'Estimate the monthly cost of CDN traffic on the pay-as-you-go Flex plan' – a specific verb (estimate), resource (monthly CDN traffic cost), and plan, clearly distinguishing it from sibling CDN management tools that list, get, purge, or warm up. It also includes pricing tier details that reinforce its 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?

The description specifies when the estimate applies (Flex plan, progressive tiers, minimum fee) and notes an exclusion: volumes over 100 TB/month qualify for custom pricing, implying the estimate may not be accurate there. It also points to current rates for up-to-date pricing, but does not explicitly name alternative tools (none exist), so it stops short of full 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 already declare readOnlyHint=true and openWorldHint=true, so the description is consistent but adds minimal behavioral context. It provides no additional details about authentication, rate limits, or what 'details' are returned. The scope ('one') is more about purpose than behavior, so the description meets the baseline without adding extra disclosure.

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

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

The description is a single concise sentence with no redundant information. It is front-loaded with the action and resource, and every word contributes to understanding the tool's purpose.

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

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

The tool is simple (one parameter, read-only, no output schema), and the description sufficiently explains what it does for an agent to select it. It could be slightly more complete by specifying what 'details' include or when to use it over siblings like get_bucket_metrics, but the current level is adequate for a straightforward get operation.

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 100% with the bucket_id parameter described as 'Bucket ID'. The description does not add additional parameter semantics beyond the schema, but it aligns with the parameter by implying the bucket is identified by ID. This matches the baseline for high schema coverage.

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

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

The description states a specific action ('Get'), a specific resource ('cloud storage bucket'), and a scope ('one'), which clearly distinguishes it from list_buckets and other sibling tools. This is a precise verb+resource+scope construction.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention that it is for retrieving a single bucket by ID, while list_buckets is for enumerating multiple buckets, nor does it reference any other related tools.

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 tool is known to be a safe read operation. The description adds the 'over a period' scope, but does not disclose further behavior such as how filtering works, whether statistics are aggregated, or what the response format is. It provides some added context but not rich behavioral detail.

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

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

The description is a single, concise sentence that immediately states its purpose. No unnecessary words or repetition, and it is front-loaded with the key action and resource.

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

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

For a read-only metrics tool with full schema coverage and readOnlyHint, the description is adequate, but it lacks specifics about what 'usage statistics' includes (e.g., bandwidth, operations count) and the response shape. There is no output schema, so the description could provide more detail on expected results to fully compensate.

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

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

The input schema has 100% description coverage for all parameters, including period, date, bucket_id, and external_storage_id. The description adds only high-level meaning ('usage statistics'), which is somewhat helpful but does not enhance the already well-documented parameter semantics. Baseline 3 is appropriate.

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

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

The description clearly states the action ('Get'), the resource ('usage statistics for cloud storage buckets'), and the scope ('over a period'). It distinguishes itself from sibling metrics tools like get_cdn_metrics and get_prometheus_metrics by explicitly targeting cloud storage buckets.

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 gives clear context for when to use the tool (for cloud storage bucket usage statistics over a period), but does not provide explicit exclusions or alternatives. With many sibling metrics tools, it would benefit from stating 'Use this for bucket metrics, not CDN or Prometheus metrics' to guide 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?

The annotations declare readOnlyHint=true and openWorldHint=true. The description adds behavioral detail beyond annotations by explaining the two time-selection modes, the ability to scope to the whole account or a single resource, and clarifying that 'responses' refers to HTTP codes. No contradiction with annotations.

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

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

The description is two concise sentences that front-load the purpose and then provide essential usage details. Every sentence contributes valuable information with no redundancy or filler.

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

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

Despite having no output schema and 9 parameters, the description covers the main scope, time-selection options, and metric types, which is sufficient for invoking the tool. It does not explain output structure, but the schema covers parameter constraints (like scale limits), so the description adequately complements the structured information.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining the mutually exclusive time-selection modes (period+date vs from+to) and clarifying the 'responses' metric type as HTTP codes, which is not obvious from the schema alone.

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

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

The description clearly states it retrieves Anycast CDN metrics for the whole account or a single resource, giving a specific verb, resource, and scope. Listing metric types further distinguishes it from sibling tools like get_prometheus_metrics and get_bucket_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?

The description provides clear usage context by explaining the two time-range selection methods (period+date or from+to) and enumerating metric types. It does not explicitly contrast with alternatives, but it gives enough context for when to use this tool over others.

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 read-only nature is covered. The description adds beyond annotations by enumerating the specific fields returned (origin, TTLs, compression, etc.), which is useful behavioral context about the response. No contradiction with annotations.

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

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

Single sentence, front-loaded with the main action (Get full details), and every word earns its place. No redundancy or filler.

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

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

For a simple read-only get tool with one well-documented parameter and no output schema, the description is complete. It lists the expected return details, making the tool's scope fully understandable.

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 100% (resource_id has a description and format). The tool description doesn't add extra meaning to the parameter, but the schema fully documents it. Baseline 3 is appropriate.

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

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

The description states a specific verb (get) and resource (Anycast CDN resource) with explicit details of what's included (origin, TTLs, compression, origin shield, domains, locations). It clearly distinguishes from siblings like list_cdn_resources and get_vcdn_resource.

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 clearly implies usage: when you need full details of a single Anycast CDN resource by ID. It does not explicitly name alternatives or exclusions, but the single-parameter design and list of returned fields make the context clear.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is clear. The description adds minimal behavioral context beyond the resource being fetched, such as 'details' but does not disclose potential errors, permissions, or return format. This is adequate but not rich, given the annotation coverage.

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

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

The description is a single sentence of nine words, with no filler or redundancy. It directly states the action and target, earning a perfect score for conciseness.

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 single-ID retrieval tool with a readOnlyHint and no output schema, the description is nearly sufficient. However, it could be improved by referencing the sibling list_external_storages to help discover IDs or clarify what 'details' include. The low complexity makes it workable, but a bit more context would make it complete.

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

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

Schema description coverage is 100%—the only parameter 'external_storage_id' is documented with its type and description. The tool description adds little beyond echoing the parameter, saying 'one external storage connection,' which does not provide additional syntax or format details. The baseline of 3 is appropriate.

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 function: 'Get details of one external storage connection.' The verb 'Get details' and the specific resource 'external storage connection' make the purpose unambiguous. It also distinguishes itself from the sibling 'list_external_storages' by explicitly focusing on a single connection.

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

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

The phrase 'one external storage connection' implies it should be used for a specific external storage ID, but it does not explicitly mention when to use this tool versus alternatives like list_external_storages. No when-not-to-use or alternatives are provided, so the usage context is only implied.

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

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

Annotations already declare readOnlyHint and openWorldHint, covering safety. The description adds meaningful context about the output format (Prometheus) and source semantics, but does not disclose details like response size, pagination, or rate limits. This is acceptable for a read-only fetch 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 a single, front-loaded sentence with zero redundant words. It immediately states the action, format, and purpose, then efficiently explains the parameter options.

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 one-parameter read-only tool, the description fully covers what it does, when to use it, and how to select the source. 'Prometheus-format' implies a standard output structure, compensating for the absence of an output schema. No gaps remain.

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

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

The schema alone lists enum values 'cdn' and 'cloud_storage' with minimal description. The tool description enriches these by explaining what each value represents ('Anycast CDN' and 'Cloud Store'), which goes beyond the schema and aids correct parameter selection.

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 function with a specific verb ('Fetch') and resource ('Prometheus-format metrics'), and explicitly maps the two source values to distinct services. This distinguishes it from sibling metrics tools like get_cdn_metrics and get_bucket_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?

Provides clear use context ('monitoring dashboards') and explains how to choose the source parameter. It does not explicitly compare against alternative metrics tools, but the intended scenarios are evident.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe, read-only operation. The description adds the specific data returned (endpoints, usage), which is helpful context beyond the annotations. However, it does not disclose any additional behavioral traits such as authentication requirements or rate limits, which the annotations also do not cover.

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

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

The description is a single, focused sentence that immediately conveys the tool's purpose. It uses no unnecessary words and is front-loaded with the action and resource.

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

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

For a tool with no parameters and no output schema, the description is sufficient: it names the resource and the key data fields (endpoints, usage). The annotations provide safety context. While it could name the return format or distinguish from siblings, the simplicity of the tool makes this 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 input schema defines zero parameters, so schema coverage is 100% and the baseline is 4. The description adds context that the tool returns account-level endpoints and usage, which clarifies the tool's scope even though no parameters exist.

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 'Get cloud storage account info (endpoints, usage).' This clearly identifies the verb 'get' and the resource 'cloud storage account info,' making the tool's purpose obvious. It distinguishes from sibling tools that target buckets, CDN resources, or external storages, though it does not name them explicitly.

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

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

The description implies use for retrieving account-level storage endpoints and usage, but it provides no explicit guidance on when to prefer this tool over alternatives like get_bucket or get_external_storage. There is no mention of excluded scenarios or alternative tools, so the agent must rely on 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?

The description merely restates the tool's function without adding behavioral details beyond the readOnlyHint annotation. It does not mention error handling, permissions, or any side effects, and openWorldHint is not elaborated.

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

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

The description is a single concise sentence with no redundant information. It is efficiently front-loaded with the verb and resource.

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?

While the tool has a simple one-parameter schema and read-only annotation, the description lacks detail on what 'details' are returned or errors. It is minimally viable but leaves the agent without full context, especially given no 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?

The input schema fully documents domain_id with a description, and the tool description adds no parameter semantics. With 100% schema coverage, the description need not repeat this information, so baseline 3 is appropriate.

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

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

The description clearly states the operation ('Get') and the resource ('details of one Video CDN domain'), specifying singularity. It distinguishes from list_vcdn_domains which lists multiple domains, though it doesn't name alternative tools explicitly.

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

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

No guidance is provided on when to use this tool versus alternatives like get_vcdn_resource or list_vcdn_domains. The description is purely functional and lacks context on 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 and openWorldHint=true, covering the read-only safety profile. The description adds that the tool returns total count and size, which is slightly more specific than the title, but it does not disclose additional behavior such as whether the totals are aggregated globally, response format, or performance implications. With annotations present, this is adequate but not rich.

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

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

The description is a single, concise sentence: 'Get total count and size of files stored on the Video CDN.' It contains no fluff or repetition, and every word contributes meaning. It is front-loaded with the verb and object, making it instantly scannable.

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

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

Given that there are no parameters, no output schema, and annotations already indicate read-only/open-world behavior, the description is sufficient to understand the tool's core function. It clearly states the tool returns total count and size for files on the Video CDN. However, it could explicitly mention that it returns a single aggregated result (rather than a list), though this is reasonable inferred from 'total'. The absence of advanced features keeps the description 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?

The tool has zero parameters, and the schema description coverage is 100% (empty properties). The baseline for 0 params is 4, and the description does not need to explain parameters. The description 'Get total count and size' already indicates the return value matches the tool's purpose, so no further param semantics are needed.

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

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

The description clearly states the verb ('get') and resource ('total count and size of files stored on the Video CDN'). It is specific enough to distinguish from siblings like list_vcdn_files (which likely lists individual files) and get_vcdn_statistics (which may cover broader metrics). The scope is unambiguous.

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

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

The description implies when to use this tool (when you need aggregate file totals), but it does not explicitly mention alternatives or exclusions. Sibling tools like list_vcdn_files suggest different use cases, but the description itself does not guide the agent to choose this over other tools. No direct when/when-not guidance is provided.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, but the description adds no additional behavioral context. There is no mention of response behavior, error handling, or any side effects, which is a gap given the low annotation coverage.

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

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

The description is a single, clear sentence with no redundant or unnecessary words. It is appropriately sized for a simple getter tool.

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

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

For a low-complexity read-only tool with a single well-documented parameter and no output schema, the description is complete enough. It could have elaborated on what 'FTP import settings' entails, but the combination of name, title, and sentence covers the essential 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?

The schema provides full documentation for the single parameter (resource_id as a vCDN resource ID) with 100% coverage. The description adds no extra semantic value beyond what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description states a clear verb ('Get') and resource ('FTP import settings of a Video CDN resource'), which precisely identifies the tool's function. It also differentiates from siblings like get_vcdn_settings (general settings) and list_ftp_logins (login list) by specifying the FTP import aspect.

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

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

There is no guidance on when to use this tool versus alternatives. The description does not mention related tools or any conditions for use, leaving the agent to infer 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 indicate readOnlyHint=true and openWorldHint=true, establishing this as a safe, read-only operation. The description adds the semantic clarification 'origin fetch' but does not disclose additional behavioral traits such as error handling, response format, or rate limits. Given the annotation coverage, 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, direct sentence that clearly communicates the tool's purpose without unnecessary words. It is front-loaded and easy to parse.

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?

This is a simple read-only getter with one parameter and no output schema. The description adequately conveys the tool's function and the resource it operates on. It lacks explicit mention of the return value or potential error conditions, but the low complexity means the description is nearly 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?

The input schema fully documents the only parameter, resource_id, with a description and format ('vCDN resource ID'). The tool description does not add any further context about parameters, but since schema coverage is 100%, the baseline score of 3 is justified.

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

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

The description clearly states the action ('Get') and the specific resource ('proxy (origin fetch) settings') of a Video CDN resource. It distinguishes this tool from sibling tools like get_vcdn_resource and get_vcdn_settings by focusing on the proxy configuration aspect.

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 a straightforward purpose but does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. Usage is implied by the tool's name and description, which is adequate but not explicit.

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

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

Annotations already declare readOnlyHint=true, and the description adds no extra behavioral context such as response format, permissions, or error behavior. It does not go beyond what the structured data conveys.

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

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

The description is a single, front-loaded sentence with no wasted words. It communicates exactly what the tool does without redundancy, making it an exemplary model of conciseness.

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 get-by-ID tool with one parameter and readOnlyHint, the description is minimally adequate. However, it does not specify what details are returned or clarify its relationship to the similarly named get_cdn_resource sibling, leaving some ambiguity.

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

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

The schema includes one required parameter (resource_id) with a clear description, achieving 100% schema description coverage. The tool description adds no semantic content beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('Video CDN resource'), clearly distinguishing it from list_vcdn_resources and other sibling tools. Though it doesn't explicitly differentiate from get_cdn_resource, the 'Video' qualifier makes the target resource unambiguous.

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 about when to use this tool versus alternatives like get_cdn_resource or when not to use it. The description simply restates the function without any contextual cues 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 the scoping detail 'account-wide default,' which provides context beyond the readOnlyHint annotation. It does not disclose other behavioral traits, but annotations already cover safety, so the description is not misleading.

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

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

The description is a single, concise sentence that immediately communicates the tool's purpose without unnecessary detail.

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

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

For a read-only, zero-parameter tool, the description fully covers the necessary context. The 'account-wide default' scope clarifies the tool's position among siblings.

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

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

The input schema has zero parameters, so the description carries no parameter burden. Baseline 4 applies.

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

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

The description uses the specific verb 'Get' and clearly identifies the resource as 'account-wide default Video CDN settings.' This distinguishes it from sibling tools that target specific resources (get_vcdn_resource) or domains (get_vcdn_domain).

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 is provided about when to use this tool versus alternatives like get_vcdn_resource or get_vcdn_statistics. The description implies a getter for defaults, but lacks any comparison 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 read-only nature is covered. The description adds valuable behavioral context by clarifying that date parameters are mandatory for most reports and providing an ISO date format example. It does not contradict annotations and goes beyond the schema by tying parameter requirements to each report type.

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 dense but efficient; each clause carries informative content. It front-loads the primary verb and resource, then lists reports in a structured sentence. It is longer than ideal, but every detail earns its place, covering all report types and requirements 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?

Given the tool's complexity (8 report types, 5 parameters, no output schema), the description covers parameter constraints and date formatting effectively. It does not describe the response structure or return values, but the report names are self-explanatory, and with annotations covering safety, the description is sufficiently complete for an AI agent to invoke correctly.

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

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

Although the schema already documents each parameter, the description significantly enhances semantics by mapping specific parameters to each report type. For instance, it specifies that 'by_domains' requires resource_id and domains, and that 'bandwidth' is optional. This mapping is not evident from the schema alone and directly aids correct invocation.

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

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

The description clearly states the tool retrieves Video CDN statistics and enumerates eight specific report types (monthly_totals, timeseries, by_domains, etc.), each with distinct scopes. This specific verb+resource pairing and the detailed report list distinguish it from sibling tools like get_cdn_metrics or list_vcdn_domains.

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 gives practical context by specifying which parameters each report requires (e.g., 'monthly_totals' requires resource_id; 'by_domains' requires resource_id and domains) and notes that start_date/end_date are required for all reports except monthly_totals. It does not explicitly name alternatives, but the report-specific guidance serves as clear usage direction.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds minimal extra behavior context, such as that it lists jobs tied to a resource, but does not disclose any further details like pagination or return format. This meets the lower bar set by the annotations without contradiction.

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

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

The description is a single, front-loaded sentence that conveys the essential purpose without any wasted words. Every word contributes meaning.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is mostly complete. It identifies the resource type and the object being listed, but it does not clarify what a 'content auto-import job' comprises or what the response list contains. This leaves a minor gap.

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

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

Schema description coverage is 100%, with resource_id described as 'vCDN resource ID'. The description adds no additional parameter meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description 'List content auto-import jobs of a Video CDN resource' uses a specific verb and resource, clearly distinguishing it from sibling tools like list_vcdn_files or list_vcdn_domains. The scope is explicit: content auto-import jobs tied to a Video CDN resource.

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 or how it compares to alternatives. No exclusions, prerequisites, or scenario-specific instructions are given, leaving the agent to infer usage solely from the tool name.

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

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

Annotations already declare readOnlyHint and openWorldHint. Description adds the scope 'all ... in the account' but provides no additional behavioral details such as result format 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?

Single sentence, front-loaded with the verb and resource, contains no redundant information.

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

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

For a simple list operation with no parameters and no output schema, the description states the essential purpose. It does not describe the return shape, but the tool's simplicity makes that a minor omission.

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

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

Tool has zero parameters, so there is nothing for the description to explain beyond the schema; baseline of 4 is appropriate.

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

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

The description uses specific verb 'List' and identifies the exact resource 'cloud storage buckets in the account', distinguishing from sibling tools like get_bucket or list_external_storages.

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 vs alternatives. The purpose is obvious from the name/description, but it doesn't mention when to prefer get_bucket or other list variants.

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?

Even with readOnlyHint and openWorldHint annotations, the description adds critical behavior: the API paginates with an undocumented default of 25, the tool requests up to 100 per call, and the agent MUST check meta.total and fetch remaining pages before reporting. This transparently disclosers a non-obvious pitfall and gives explicit instruction on how the tool behaves.

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 three sentences, each earning its place: purpose, pagination nuanced behavior, hard instruction to paginate. It is front-loaded with the most important information and contains no filler.

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

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

Given a 3-parameter tool with no output schema, the description provides sufficient context by naming exactly what is returned (settings, domains, state), explaining pagination, and warning about the meta.total pitfall. The input schema documents the parameters and additionalProperties false, and the annotations add the open-world/read-only context. Together this is a complete picture for an agent to use the tool effectively.

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

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

Schema covers 100% with descriptions for page, per_page, and traffic_distribution, so the bar for adding value is partly satisfied. The description goes beyond the schema by explaining why pagination parameters matter ('API paginates, its own default is 25 per page, undocumented') and why the agent needs to use page, effectively clarifying the purpose behind page/per_page behavior.

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

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

The description opens with a specific verb and resource: 'List Anycast CDN resources (pull zones) in the account with their settings, domains and state.' It clearly distinguishes this as the account-level listing tool, contrasting with siblings like get_cdn_resource and get_cdn_metrics by focusing on the enumeration of CDN resources themselves.

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: this is for listing all Anycast CDN resources in the account, and it instructs the agent to paginate through meta.total until all resources are retrieved. However, it does not explicitly call out when to prefer get_cdn_resource for a single zone or mention any exclusions, so it falls short of full explicit 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?

The readOnlyHint annotation already communicates that this is a safe read operation. The description adds value beyond annotations by specifying that the result includes SSL status and that the domains are scoped to an aCDN resource. This is useful context, though it does not describe pagination 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 a single, front-loaded sentence that communicates the core purpose and an additional detail (SSL status) with no wasted words. Every 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?

For a simple read-only list tool with one parameter, strong annotations (readOnlyHint, openWorldHint), and no output schema, the description covers the essential scope and return detail. It is complete enough for an agent to select and invoke the tool correctly without further 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?

The schema already provides a 100% description coverage for the single parameter, resource_id, as 'aCDN resource (pull zone) ID'. The description does not add syntax or format details beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('List') and resource scope ('custom domains attached to an aCDN resource'), and adds useful detail ('including SSL status'). This clearly distinguishes it from sibling tools like list_vcdn_domains or search_custom_domains, which target different resource types or purposes.

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: it is used to list custom domains for a specific aCDN resource. However, it does not explicitly mention when not to use it or name alternatives (e.g., search_custom_domains). The scope is clear enough to infer the primary use case, so it earns a 4 rather than a 5.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the contextual detail that storages are 'configured' and 'used as CDN origins,' which is helpful but does not disclose any additional behavioral aspects such as return format, pagination, or limitations. This meets the lowered bar but does not exceed it.

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 sentence that is concise, front-loaded with the verb and resource, and contains no extraneous information. Every word adds value.

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

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

Given the tool's simplicity (0 parameters, no output schema), the description is complete. It clearly identifies what the tool returns (configured external storages) and their purpose (CDN origins), which is sufficient for an agent to invoke correctly. Annotations cover the read-only 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?

There are no parameters, and the schema coverage is 100%. According to the rubric, 0 parameters merits a baseline of 4. The description does not need to explain parameters, and no additional parameter semantics are required.

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 lists configured external (S3-compatible) storages used as CDN origins, specifying both the verb (list) and the resource (external storages). This distinguishes it from sibling tools like list_buckets or get_external_storage by clarifying the scope (external S3-compatible, CDN origins).

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 establishes clear usage context by specifying the type of storages (external S3-compatible CDN origins), which helps the agent decide when to use this tool versus listing internal buckets or retrieving a single storage. It does not explicitly mention alternatives or exclusions, but the context is strong enough for most cases.

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 agent knows this is a safe read operation. The description adds the FTP/SFTP scope but does not disclose any behavioral traits beyond that, such as whether passwords are returned or any permission requirements. This is adequate given the annotation coverage, but lacking extra context.

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

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

The description is a single concise sentence that effectively communicates the tool's purpose without redundancy. It is appropriately front-loaded and contains no wasted words.

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 of the tool (one parameter, no output schema), the description is sufficiently complete. It identifies the resource type and the nature of the data returned. However, it could optionally mention that it specifically targets FTP/SFTP logins and possibly note the distinction from FTP settings, but this is not a significant gap.

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

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

The schema description covers 100% of parameters, with resource_id described as 'vCDN resource ID'. The description's mention of 'Video CDN resource' reinforces but does not add new meaning beyond the schema. With full schema coverage, the baseline of 3 is appropriate.

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 'List FTP/SFTP logins of a Video CDN resource,' specifying a specific verb (list), resource type (FTP/SFTP logins), and scope (Video CDN resource). This distinguishes it from sibling tools like get_vcdn_ftp_settings, which deals with settings rather than logins.

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 when FTP/SFTP login details are needed for a Video CDN resource, but it does not explicitly state when to use it versus alternatives or mention any exclusions. Sibling tools such as get_vcdn_ftp_settings are not referenced, so guidance is only implicit, not explicit.

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

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

The annotations already provide readOnlyHint and openWorldHint. The description adds that these are system-provided zones for CDN, but doesn't disclose additional behavioral traits like return format or ordering. Given the annotations, this is adequate but not rich.

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

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

The description is a single sentence, front-loaded with the action and resource, and contains no filler. Every word contributes to understanding the tool's 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 parameterless, read-only list tool with annotations covering safety, the description is sufficient. It clearly explains what the tool does and why it would be used, and no output schema is needed for such a simple operation.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description does not need to explain any parameter semantics, as there are none.

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

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

The description clearly states the action (List) and the specific resource (system DNS zones), and adds the scope 'available for CDN domain names' and 'used when creating aCDN resources'. This distinguishes it from sibling tools like list_custom_domains or list_vcdn_domains.

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?

It explicitly identifies the usage context: these zones are used when creating CDN resources. This gives the agent clear guidance on when to call this tool, though it does not mention exclusions or 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?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds that filtering is possible, but this is already evident from the schema. No additional behavioral traits such as pagination, default limits, or return format are disclosed. This is adequate but not enriching 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 a single, front-loaded sentence that states the verb, resource, and optional filters without any fluff. Every word earns its place, making it highly concise and well-structured.

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 list tool with two optional filter parameters and no required fields, the description covers the core function. The absence of an output schema is acceptable because the name and annotations suggest it returns a list of domains. However, it could be slightly more complete by hinting at the return structure or any limitations, but overall it is sufficient for the tool's simplicity.

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 100%, with both parameters ('domains', 'ssl_certificate_ids') documented. The description's mention of 'filtered by name or SSL certificate' restates what the schema already provides, adding no new meaning. Baseline 3 is appropriate because the schema carries the full parameter detail.

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

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

The description clearly states the action ('List') and resource ('Video CDN domains'), which distinguishes it from sibling tools like get_vcdn_domain (singular) or list_cdn_resources (a different resource type). It also mentions optional filters, adding clarity. However, it does not explicitly differentiate from list_vcdn_resources, which could be similar in scope.

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

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

No guidance is provided on when to use this tool versus alternatives. There are many sibling tools (e.g., list_vcdn_resources, list_custom_domains), but the description does not mention any exclusions or specific scenarios. The openWorldHint annotation is present but not leveraged to explain when this tool is appropriate.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, covering the safety profile. The description adds minimal behavioral context by noting filtering/sorting/pagination, but does not disclose response format, pagination defaults, or any additional constraints. With annotations handling the key safety traits, a 3 is appropriate.

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

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

The description is a single, front-loaded sentence that states the action, resource, and key capabilities without any fluff. Every word contributes to understanding the tool's 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?

With 10 parameters, 60% lacking schema descriptions, and no output schema, the description is too sparse. It does not explain the expected response structure, default pagination behavior, date formats, or which fields are sortable/filterable. This leaves significant gaps for an agent to use the tool correctly.

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

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

Schema description coverage is only 40%, leaving six parameters undocumented. The description mentions filtering, sorting, and pagination at a high level but does not map them to specific fields like page, per_page, sort_order, sort_field_name, start_date, or end_date. The agent would need to infer parameter meaning from names alone, which is insufficient.

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

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

The description uses a specific verb ('List') and resource ('files stored on the Video CDN'), clearly distinguishing it from siblings like list_vcdn_resources (which lists resources) and get_vcdn_files_total (which likely returns a count). The mention of filtering, sorting, and pagination further clarifies the tool's scope.

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

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

The description implies the primary use case: to retrieve files from the Video CDN with the ability to filter, sort, and paginate. While it does not explicitly name alternatives or exclusion criteria, the context is clear enough for an agent to choose this over sibling tools like list_vcdn_resources or get_vcdn_files_total.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is known. The description adds no behavioral details such as response format, pagination, ordering, or any caveats. It adds little beyond the scope, thus not contributing additional 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 a single, concise sentence: 'List all Video CDN resources in the account.' It is front-loaded with the action and resource, contains no extraneous words, and is appropriately sized for the tool's simplicity.

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?

This is a parameterless list tool with no output schema, so the description must carry the burden of explaining what the tool returns. It states the core function but does not describe what a vCDN resource is, the response structure, or any limitations. It is minimally viable but lacks detail to fully orient the 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 tool has zero parameters, and the schema is empty. According to the rubric, 0 params earns a baseline of 4. The description correctly innuates a simple list call with no inputs, aligning with schema coverage of 100%.

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

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

The description clearly states the action ('List'), the resource type ('Video CDN resources'), and the scope ('in the account'). It distinguishes from sibling tools like list_vcdn_domains and list_vcdn_files, though it doesn't explicitly define what a 'resource' is. A clear verb+resource+scope is present, earning a 4.

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 such as list_cdn_resources or get_vcdn_resource. There are no explicit conditions, exclusions, or alternative tools mentioned, leaving the agent without 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?

The description adds useful behavioral context beyond the annotations: the automatic domain-based zone matching when resource_id is omitted, and the distinction between full-URL and resource-scoped purging. Annotations already indicate idempotent, non-destructive behavior, so the bar is lower, but this description still contributes meaningful details.

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

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

Two concise sentences efficiently pack all essential information. The structure clearly separates the two modes, making it easy to parse. Zero wasted words.

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

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

For a tool with 3 parameters and no output schema, the description fully covers the key scenarios and edge cases (resource_id vs no resource_id, clear_all vs specific URLs). It is complete for an agent to understand and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description enhances parameter understanding by explaining the interplay between resource_id, clear_all, and urls: how resource_id changes the scope and meaning of the other parameters. This adds value beyond the individual field 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 purges cached content, using a specific verb+resource structure. It also distinguishes the two primary usage modes (with and without resource_id), which differentiates it from sibling tools like warmup_cache (which pre-loads rather than purges).

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 explicit guidance on when to use each mode: with resource_id for resource-scoped purges (all or specific URLs), and without resource_id for URL-based purges across all resources. It does not explicitly name alternatives like warmup_cache for the inverse operation, but the usage context is clear.

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 Annotations readOnlyHint=true and openWorldHint=true, the safe, read-only nature is already declared. The description adds meaningful behavioral context beyond annotations: it states that the tool searches all custom domains in the account and returns the resource assignment for matches, which is useful for understanding the tool's full reach and result semantics.

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

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

A single, well-structured sentence that leads with the action and resource, followed by a clarifying parenthetical. No wasted words or redundant details.

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

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

For a tool with one optional parameter and no output schema, the description gives enough context: it clarifies the matching scope and the kind of result ('which resource serves which domain'). The lack of an output schema is partially compensated by the parenthetical. Minor gaps include what happens when no domains are provided, but overall it is sufficiently complete for its simplicity.

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

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

The schema already fully describes the only parameter 'domains' as 'Domain names to match' (100% coverage). The description reinforces this connection but does not add new syntactic or formatting details beyond what the schema provides. The parenthetical is about output behavior, not parameter semantics, so baseline 3 is appropriate.

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

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

The description uses a specific verb 'Match' and identifies the resource 'custom domains' and the scope 'in the account', clearly distinguishing it from sibling tools like list_custom_domains. The parenthetical '(which resource serves which domain)' clarifies the output purpose, leaving no ambiguity.

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

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

The description implies a clear usage scenario: when you have domain names and need to find the corresponding serving resource, rather than merely listing all custom domains. However, it does not explicitly mention alternatives or when not to use the tool, so it stops short of a perfect score.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds a critical behavioral detail: the tool returns matching pages with URLs, and users must fetch a URL for full details. This clarifies that the tool does not return page content, exceeding annotation coverage.

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

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

The description is two sentences, front-loaded with the core purpose, and every word earns its place. It includes the essential behavior (returns URLs) and a pointer for full details without unnecessary elaboration.

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 (one required parameter, no output schema, read-only annotation), the description provides enough context for a user to understand what to expect: a list of pages with URLs. It could be slightly more explicit about the result format, but for this low complexity, it is sufficient.

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 100% for the single 'query' parameter, with concrete examples provided. The description's mention of 'keyword' aligns with the schema but adds no new semantic information beyond what the schema already offers, so the baseline score is appropriate.

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

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

The description clearly states a specific verb ('Search') and resource ('BlazingCDN public documentation and product pages'), and the keyword-based search behavior. It distinguishes from sibling tool 'search_custom_domains' which focuses on custom domains, so the purpose is unambiguous.

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

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

The description makes it clear when to use this tool (searching public docs/product pages), and the context signals include sibling search_custom_domains, implying a distinction for domain-specific searches. However, it does not explicitly state exclusions or alternatives, only implying them through resource specificity.

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 idempotentHint=true and destructiveHint=false, covering the safety profile. The description adds that it warms the cache for given paths and optionally per compression method, but it does not disclose additional behavioral traits such as origin fetch side effects, rate limits, or whether the operation is asynchronous.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose and optional parameter. No fluff or repetition, every word earns its place.

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

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

For a simple tool with three well-documented parameters, strong annotations (idempotent, non-destructive), and no output schema or nested objects, the description is largely complete. The only minor gap is that it does not mention the return value or whether the operation is asynchronous, but this is not critical given how well the schema and annotations cover the details.

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 100%, with each parameter already having a descriptive definition (paths, resource_id, compression_methods). The description only summarizes these, adding no new semantic detail beyond what the schema already provides, so the baseline 3 applies.

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 (Pre-fetch/warm up), the target resource (aCDN resource cache), and the scope (given paths, optionally per compression method). This distinguishes it from sibling tools like purge_cache (which invalidates cache) and list/get tools (which read).

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 through the term 'pre-fetch' (i.e., use when you want to proactively populate the cache), but it does not explicitly state when to use this tool versus alternatives like purge_cache, nor does it mention prerequisites (e.g., compression method must be enabled on the resource).

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