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

The annotation already declares readOnlyHint=true, so the description's 'Get details' is consistent and adds no extra behavioral context (e.g., no mention of what is returned, pagination, or error behavior). It adds minimal value 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, front-loaded sentence with zero filler. It states exactly what the tool does 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 simple get-by-ID operation with good schema coverage and read-only annotation, the description is adequate. It omits return format but this is typically expected from a get operation and is not critical given the simplicity and 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 provides 100% coverage with descriptions for all three parameters (datacenter_id, application_loadbalancer_id, depth). The description adds no parameter-specific information, so it meets the baseline but does not enhance 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 clearly states the tool retrieves details of a specific application load balancer, distinguishing it from list_application_loadbalancers (which lists all) and get_loadbalancer (different resource). The verb 'Get details' plus resource specificity 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?

It's implicit that you use this tool when you have the ALB ID and need a single resource's details. While it doesn't explicitly name alternatives or state when not to use it, the context is clear given the sibling list_application_loadbalancers and the narrow scope of a 'specific' ALB.

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 full burden. It states the tool returns specifications without side effects, but does not detail auth requirements, rate limits, or response size. However, for a read-only specification retrieval, the information is adequate.

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 sentences, zero wasted words. First sentence states what is returned, second sentence gives usage guidance. Front-loaded with key 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?

Given no parameters and no output schema, the description is nearly complete. It explains the tool's purpose and when to use it. Could optionally mention the format of the returned spec, but not essential for agent 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?

With zero parameters, baseline is 4 per rubric. The description adds no parameter information since none exist, and the schema already covers all. No need for additional semantics.

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 returns the FOCUS v1.3 column specification and IONOS-to-FOCUS field mappings, distinguishing it from sibling tools that retrieve billing data or resources. The verb 'returns' with specific resource makes the purpose 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 explicitly says when to call the tool ('before mapping IONOS invoice/usage/traffic data to FOCUS format' or 'when user asks for FOCUS-compliant cost output'). It does not mention when not to use or alternatives, but the context is clear and no sibling tool serves the same purpose.

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 does not disclose permissions, rate limits, output format details, or any side effects. Only states it gives a line-item breakdown.

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 are front-loaded with the core purpose, include a usage hint, and a format option. 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?

No output schema exists, so description should explain return values more. It mentions 'detailed line-item breakdown' but omits structure, error handling, or pagination. Adequate for a simple read 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?

Schema covers 100% of parameters with descriptions. The description adds no additional parameter-specific meaning beyond restating that it gets invoice details. 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 it retrieves a detailed line-item breakdown for a specific invoice by ID, and distinguishes it from the sibling list tool by advising to use list_billing_invoices first to find IDs.

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?

Explicitly guides to use list_billing_invoices first to find invoice IDs, and mentions FOCUS v1.3 output. Lacks explicit when-not-to-use or alternative tool comparisons.

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 disclose behavioral traits. It only says 'Get the billing profile' without mentioning side effects, authentication needs, rate limits, or response structure beyond a hint about a contract number. This is insufficient for a tool with no 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, front-loading the purpose and key usage guidance. Every sentence contributes meaningful information 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 no output schema and no annotations, the description should explain the return value minimally. It mentions the contract number but doesn't describe the full billing profile structure or other possible fields. This is a moderate gap for a simple 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 tool has zero parameters, so the baseline is 4. The description adds value by revealing that the response contains a 'contract number' required by other billing tools, providing semantic context 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 explicitly states 'Get the billing profile for your IONOS CLOUD account.' It uses a specific verb ('Get') and resource ('billing profile'), clearly distinguishing it from sibling tools like 'get_contract' or other billing-related tools.

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 usage guidance: 'Call this first before any other billing tool — the contract number in the response is required by all other billing tools.' This tells the agent when to use this tool and why it's a prerequisite.

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, so description carries full burden. Mentions default exclusion of zero-quantity meters and how to override. Also references FOCUS v1.3 compliant output. However, does not discuss permissions, error cases, or 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?

Two sentences plus a note on FOCUS. Efficient, no redundant information. Every sentence 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?

No output schema provided, but description does not explain return value structure or fields. For a tool that returns usage data, this is a notable gap. Otherwise, the description covers usage context 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?

Schema coverage is 100%, so baseline is 3. Description adds context for contract (from get_billing_profile) and include_zero (default false, FOCUS reference), but adds little beyond 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?

Clearly states 'Get aggregated resource usage for a specific datacenter (VDC UUID) in the current billing period.' Identifies verb, resource, and scope. Distinguishes from siblings by mentioning datacenter ID and referencing list_billing_usage.

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?

Explicitly advises 'Use list_billing_usage first to find datacenter IDs.' Also explains default behavior for include_zero. Provides clear context for when to use, though lacks explicit 'when not to use' 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?

With no annotations provided, the description must disclose all behavioral traits. It mentions a response size constraint (25 KB) and refers to 'compaction flags', but does not discuss idempotency, data freshness, rate limits, or side effects. The description is insufficient for full 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 concise, consisting of three sentences that sequentially cover purpose, usage, and parameter advice. It is front-loaded with the core purpose. Every sentence adds value, though it could be slightly 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 the complexity of 8 parameters and no output schema or annotations, the description provides essential usage context and size constraints but does not explain return format, pagination, or error conditions. It relies on the schema for parameter details, making it minimally 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 already provides complete descriptions for all 8 parameters (100% coverage). The description adds value by explaining how to combine parameters (e.g., using top_n with group_by) to control output size, which goes beyond the schema's individual 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 the tool retrieves per-resource utilization for a specific date, indicating its purpose and day-level granularity. It references sibling list_billing_utilization for compaction flags, which provides context, but does not explicitly differentiate from all sibling billing tools.

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 using parameters like regions, datacenter_id, meter_types, and top_n to manage response size, including a concrete size limit. It also gives a FOCUS compliance reference. However, it lacks explicit when-not-to-use advice or comparisons to alternatives beyond mentioning the sibling.

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=true annotation and does not contradict it. It also does not add meaningful behavioral detail beyond the annotation, such as error behavior or response format, although nothing obviously harmful is hidden.

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 states the verb, the resource, and the identifying parameter in the most efficient form possible.

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 well-documented required parameter and a read-only annotation, the description is nearly complete. It could be slightly stronger by pointing to list_cert_auto_certificates as the way to discover IDs, or by noting what 'details' includes, but the core calling information is present.

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%, and the schema already documents auto_certificate_id as 'the ID of the auto-certificate'. The description only repeats 'by ID' and adds no extra semantics about value format, source, or constraints.

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

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

The description uses a specific verb ('Get') and a specific resource ('auto-certificate'), and 'specific ... by ID' clearly distinguishes this from sibling list_cert_auto_certificates, which would return multiple records. The resource term also separates it from get_cert_certificate.

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 such as list_cert_auto_certificates or get_cert_certificate. It provides no conditions, 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?

Annotations declare readOnlyHint=true, so the safety profile is already known. The description adds the useful detail that the private key is not returned, which is a behavioral boundary beyond the annotation. However, it doesn't disclose other potential behaviors like error conditions or whether the certificate must be active.

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 sentences with no wasted words. The core purpose is front-loaded, and the important exclusion (no private key) is stated concisely. Every sentence 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 single-parameter read tool with annotations covering safety, the description is nearly complete. It tells the agent what is returned (metadata and public key) and what is not (private key). The only minor gap is not describing the exact response structure, but no output schema exists and the tool is simple enough that this is a small omission.

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

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

Schema description coverage is 100%, so the single parameter certificate_id is already fully documented in the schema. The description adds no additional meaning about the parameter beyond what the schema 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 tool retrieves details of a specific certificate by ID, distinguishing it from list operations like list_cert_certificates. It doesn't explicitly name sibling alternatives, but the verb 'get' plus 'specific' and 'by ID' makes the purpose clear.

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 this is for fetching a single certificate's details, contrasting with list tools, but it doesn't explicitly state when to use this vs alternatives or mention any exclusions. The context is clear enough for an agent to infer usage, but no explicit 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?

Beyond the readOnlyHint annotation, the description reveals that the returned provider configuration deliberately excludes the external account binding secret. This is a critical behavioral detail that prevents agents from expecting a secret field and adds genuine value.

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 tightly written sentences with no filler. The primary purpose is front-loaded, and the second sentence adds an important caveat 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?

With no output schema, the description provides essential output context by noting what is included and, more importantly, what is excluded. For a one-parameter read-only getter, this is sufficient, though an example or field enumeration could push it to 5.

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 already fully documents the single provider_id parameter with a clear description. The tool description adds no additional parameter-level detail beyond restating 'by ID', 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 uses a specific verb ('Get'), a clear resource ('certificate provider'), and a precise scope ('by ID'). This unambiguously distinguishes it from the sibling list_cert_providers, so an agent can immediately understand what it does.

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 'by ID' clearly signals that this tool is for fetching a single known provider rather than listing providers. It does not explicitly name the alternative list_cert_providers, but the context is clear enough that an agent can infer when to use 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?

The annotation readOnlyHint=true already signals a safe read operation. The description adds no extra behavioral context beyond restating the purpose. It does not disclose what resource limits are included, any authentication requirements, or other effects. Since annotations carry the burden, 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 sentence with no filler or repetition. It conveys the essential information efficiently, adhering to strong 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 one-parameter read-only tool, the description is adequate but leaves ambiguity about what 'resource limit information' entails. Without an output schema, the agent might not know the exact structure. Given low complexity, it's reasonably complete but not outstanding.

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 fully describes the only parameter 'depth' with a clear description, so schema coverage is 100%. The description adds no additional meaning about parameters, which is acceptable given the schema's clarity. Baseline 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 verb 'Get' and the resource 'contract and resource limit information' for an IONOS cloud account. This is specific and distinguishes it from sibling tools like 'list_activitylog_contracts' or other get_* tools for different resources.

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

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

The description indicates what the tool does but provides no guidance on when to use it versus alternatives. Since there is no direct sibling for fetching contract info, the implied usage is clear, but explicit context is lacking. No mention of when not to use it or which alternative to choose.

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

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

Annotations already mark readOnlyHint=true, so the description adds no behavioral transparency beyond that. It does not mention any additional side effects, return format, or depth behavior beyond what the schema's 'depth' field describes. No contradiction with annotations, but no added value either.

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, tightly worded sentence that states the purpose without fluff. All words contribute value. Length is appropriate 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?

For a simple read operation with a readOnlyHint annotation and fully documented parameters, the description sufficiently conveys the tool's purpose. It does not specify what 'details' includes, but the tool name and schema (datacenter_id, depth) provide enough context for an agent. Slight gap: no mention of the depth parameter's effect on output, though the schema description does cover it.

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% (both 'datacenter_id' and 'depth' are described). The description itself adds no extra meaning to the parameters; it only rephrases 'specific' which aligns with the ID parameter. Baseline score of 3 is appropriate since the schema carries the parameter semantics.

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 ('details of a specific virtual data center'). The word 'specific' implicitly distinguishes this from the sibling list_datacenters, though it does not name the alternative explicitly. Strong purpose clarity, but not maximally 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 provides no explicit guidance on when to use this tool versus alternatives. It implies use when you have a specific datacenter ID (via 'specific'), but does not mention prerequisites, typical scenarios, or contrast with list_datacenters. The context is reasonable for a get_* tool, but exclusions or selection criteria are absent.

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 signals a safe read operation, and the description is consistent with that. It adds context that the tool returns usage and limit values, but provides no further behavioral detail such as auth requirements, rate limits, or whether the quota applies to the whole account only.

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 with no filler, front-loads the action verb, and conveys the full purpose efficiently. 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?

For a no-input, read-only quota tool, the description is nearly complete: it identifies the exact resource, scope, and general return content ('usage and limits'). It would benefit from naming the actual quota fields or return structure since there is no output schema, but the tool is simple enough that an agent can correctly select and invoke it.

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 zero parameters, the empty input schema is sufficient and the baseline is 4. The description does not need to explain parameter meaning, and it adds no unnecessary parameter confusion.

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'), names the resource ('DNS quota usage and limits'), and scopes it to the IONOS CLOUD account. This clearly distinguishes it from DNS zone/resource/list siblings like get_dns_zone or list_dns_zones, even without reading their schemas.

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

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

The description implies usage for checking account-wide DNS quota/limits, and the zero-parameter schema makes invocation straightforward. However, there is no explicit guidance about when to prefer this tool over alternative account or DNS tools, nor any exclusions when it should not be used.

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 structured data. The description merely restates the operation and adds no behavioral context such as error behavior, permissions, response shape, or side effects. It provides no value beyond what the annotation already communicates.

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, short sentence that directly states the operation. Every word is meaningful, and the core action and resource are front-loaded without any 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?

The simple two-parameter schema and readOnlyHint annotation cover the essential invocation requirements. However, with no output schema, 'details' is vague and the agent cannot know what fields the response will contain. This is adequate but 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 both zone_id and record_id clearly documented. The description adds no parameter-level meaning beyond restating the zone context, 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 a specific verb and resource: get details of a specific DNS record in a zone. The singular 'specific' distinguishes it from sibling list tools like list_dns_records and list_dns_zone_records without any 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 verb and resource imply this tool is for fetching a single DNS record once its IDs are known, but the description gives no explicit when-to-use guidance or exclusions. It does not mention that list_dns_records or list_dns_zone_records should be used to discover record IDs first.

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 covered. The description is consistent with that and adds no contradictory behavioral claims, but it also does not add context about error behavior, pagination, or response contents 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?

A single, direct sentence that immediately conveys the operation and scope. There is no filler or redundant 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?

For a simple get-by-ID tool with one well-documented parameter and a readOnly annotation, the description is mostly complete. It could mention what kind of details are returned or not-found behavior, but the lack of an output schema and the simplicity of the operation keep the gap small.

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, reverse_record_id, is already described as 'the ID of the reverse DNS record'. The description adds no additional semantic detail, 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 specific verb ('Get'), a specific resource ('specific reverse DNS record'), and explicitly scopes it to a single record rather than a list. This differentiates it from sibling list_dns_reverse_records and similar DNS getters.

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 this tool is for retrieving one specific record by ID, especially given sibling list_dns_reverse_records exists. However, it does not explicitly say when to prefer this over alternatives or mention that listing should be done with the sibling 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?

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds no behavioral context beyond the basic get operation, which is acceptable for a simple read. It does not contradict annotations and doesn't need to repeat them. However, it offers no additional nuance like authentication or response format, which would be nice but not essential here.

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

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

One sentence with no filler. The description is front-loaded and wastes no words. It effectively communicates the core action 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?

For a simple read tool with a single parameter and no output schema, the description is largely complete. It clearly identifies the resource and action. The absence of output format details is minor since no output schema exists and the tool is straightforward. An agent can call it correctly with the given information.

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

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

The schema covers 100% of the single parameter with a clear description ('the ID of the secondary DNS zone'). The tool description adds no extra meaning beyond what the schema already provides. Baseline 3 is appropriate given 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 clear verb ('Get') and resource ('details of a specific secondary DNS zone'). It distinguishes from list_dns_secondary_zones (listing all) and get_dns_secondary_zone_axfr (fetching AXFR records) through the specific phrasing, though it doesn't explicitly name the siblings. 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?

No guidance is provided on when to use this tool versus alternatives. While the sibling names hint at distinctions (list vs. get, axfr vs. general details), the description does not state when to choose this over get_dns_secondary_zone_axfr or list_dns_secondary_zones. An agent must infer from naming conventions.

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 safety profile is known. The description adds that it retrieves 'status' (not triggering a transfer), which is useful clarification. However, it does not describe what the status values look like, response format, or any other behavioral context. Given annotation coverage, a mid score 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?

A single, well-structured sentence that front-loads the key action and resource. No filler or redundancy; 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, read-only getter with one well-documented parameter, the description is nearly complete. It clearly states the operation and the object. The only gap is that 'zone transfer status' is not elaborated (e.g., possible values), but this is acceptable given the domain context and annotations.

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% for the single parameter secondary_zone_id. The description only restates the parameter conceptually ('specific secondary DNS zone'), adding no additional meaning beyond the schema. Per the baseline rule for high schema coverage, a score of 3 is correct.

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 ('zone transfer (AXFR) status of a specific secondary DNS zone'). It is clearly distinguished from siblings like get_dns_secondary_zone (which gets the zone itself) and list_dns_secondary_zone_records (which lists records). 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 gives no guidance on when to use this tool versus alternatives. It does not mention related tools like get_dns_secondary_zone or list_dns_secondary_zone_records, nor does it state prerequisites or exclusions. The usage is only implied by the name and the single parameter.

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, stating a read operation. It adds minimal behavioral context beyond the annotation, such as that it targets a specific zone, but does not disclose return format or any additional behaviors. Since annotations already cover the read-only nature, this is acceptable but not enriched.

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 front-loads the action and resource and earns its place.

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

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

Given the low complexity (one required parameter, no output schema, read-only annotation), the description is mostly complete. However, 'details' is somewhat vague and could specify what kind of details are returned, though this is a minor gap for such a simple get-by-ID 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?

Schema coverage is 100% for the single zone_id parameter, and the schema describes it as 'the ID of the DNS zone'. The description only implies the parameter via 'specific DNS zone', adding no new semantic information. 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 clear verb ('Get') and resource ('DNS zone') with the qualifier 'specific' to indicate retrieval by ID. This distinguishes it from sibling list operations like list_dns_zones and from other get_* tools for different resources (e.g., get_dns_record).

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. It does not mention that a zone_id must first be obtained, nor does it reference sibling tools like list_dns_zones for discovery. The agent must infer usage from the schema and 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=true, so the safety profile is covered. The description adds value by disclosing that the output is a BIND-format zone file, which is a useful behavioral trait. However, it does not mention potential size concerns, response format specifics, or any other side effects, so it adds only modest context 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, front-loaded sentence that names the action, resource, format, and scope with zero fluff. Every word contributes to usability, making it an exemplar of concise 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?

For a simple one-parameter, read-only tool with no output schema, the description covers what is returned (BIND-format zone file) and the required input (specific zone). It is sufficient for correct invocation, though it could mention whether the zone file is returned as a raw string or with any special encoding.

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

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

The schema has 100% description coverage for the single parameter zone_id ('the ID of the DNS zone'). The description adds no additional meaning for the parameter, so the baseline of 3 applies per the scoring rubric.

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 ('Get') and resource ('zone file') with an explicit format qualifier ('BIND format'), and scopes it to a specific DNS zone via zone_id. This distinguishes it from sibling tools like get_dns_zone (metadata) and list_dns_zone_records (individual records), so an agent can identify the right tool.

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 no explicit guidance on when to use this tool versus alternatives such as get_dns_zone or list_dns_zone_records. It only implies the tool is used for the full BIND-format zone file, but there is no when/when-not or alternative routing, leaving the selection entirely to the agent's inference.

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 already declares readOnlyHint: true, so the description adds no extra behavioral context beyond what's implicitly known. It doesn't mention anything about the response format, pagination, or error behaviors. Since the annotation covers the safety profile, a 3 is appropriate—the description doesn't contradict but also doesn't enrich beyond the structured data.

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 details of a specific firewall rule') with zero waste. It's front-loaded and easy to parse. For a simple getter, this is appropriately minimal.

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 operation (a single getter), the readOnlyHint annotation, and complete schema documentation, the description is sufficient. The only minor gap is not explaining that firewall rules are nested resources requiring datacenter/server/NIC IDs, but this is inferable from the required parameters. Overall, it's complete for its complexity level.

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 100% coverage for all 5 parameters, each with a description. The tool description adds no additional meaning about the parameters—it doesn't explain the hierarchy (e.g., that a firewall rule belongs to a NIC, which belongs to a server) or any special constraints. Baseline 3 is correct when the schema carries the full burden.

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 ('details of a specific firewall rule'), which distinguishes it from list operations like list_firewall_rules. However, it doesn't explicitly differentiate from other getters like get_security_group_rule, though the name itself is unambiguous enough. This meets the bar for clear but not exceptional.

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 list_firewall_rules or get_nic. There's no mention of prerequisites (e.g., needing datacenter/server/NIC IDs) or any context for why one would retrieve a single rule. The usage context is only implied by the name and 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?

The readOnlyHint annotation already indicates that this operation is read-only. The description does not add any additional behavioral context, such as potential rate limits, data format, or side effects, but it does not contradict the annotation. With annotation present, a neutral score 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 with no redundancy. It directly communicates the purpose without extraneous 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 simple read operation with no output schema, the description adequately covers the core functionality. It does not elaborate on the returned details, but this is implied by the nature of a get operation. The lack of output schema reduces the need for further explanation.

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?

Both parameters (ipblock_id and depth) are already fully described in the schema. The description does not add any extra semantic information beyond what the schema provides, so the baseline score for high coverage is used.

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 details') and the resource ('specific reserved IP block'). It distinguishes from list_ip_blocks by indicating specificity, and the verb-resource combination leaves 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?

No explicit guidance on when to use this tool versus alternatives (e.g., listing all IP blocks). It does not mention that it should be used when the caller already knows the IP block ID or any context that would trigger its 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?

The description adds meaningful behavioral context beyond the readOnlyHint annotation by specifying exactly what information is returned and how it supports upgrade planning. Since there is no output schema, this detail is valuable and gives the agent a strong sense of the tool's behavior without contradicting 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 sentences long and every clause earns its place: the first defines scope and output, the second provides actionable upgrade context. It is front-loaded 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 the tool's moderate complexity, no output schema, and readOnly annotation, the description covers the main return values and a key use case (pre-upgrade checks). It could be slightly more complete by explicitly noting that this is for a single cluster and that list_k8s_clusters serves the multi-cluster case, but the core context is present.

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 already has 100% description coverage for both parameters, so the description does not need to explain them. It adds no additional parameter-level semantics beyond reinforcing that k8s_cluster_id identifies a specific cluster, which is already implied by 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 operation: 'Get details of a specific Kubernetes cluster' and enumerates the returned attributes (state, version, maintenance window, allow list, public/private). This distinguishes it from list_k8s_clusters and other get_* siblings by targeting a single cluster with a specific ID.

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 explicit guidance: 'Read this before an upgrade' and explains how the returned fields (availableUpgradeVersions, viableNodePoolVersions) relate to update_k8s_cluster. It lacks an explicit 'when not to use' or a direct comparison with list_k8s_clusters, but the intended 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?

The description adds context beyond the readOnlyHint annotation by explaining the tool's behavioral link to create_k8s_cluster and the k8s_version parameter omission case. It consistently supports the read-only nature indicated by the annotation 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?

Two sentences with zero waste. The first front-loads the primary action, and the second provides essential relational context about the create flow.

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 zero-parameter read-only lookup with no output schema, the description is complete: it defines what it returns, its relevance to new clusters and node pools, and how it fits into the cluster creation workflow. There is nothing more an agent would need to know.

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 description has no parameter semantics to clarify. The baseline of 4 applies as there's nothing for the description to compensate for, and it appropriately focuses on what the tool returns.

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 'the current default Kubernetes version used by new clusters and node pools in I IONOS CLOUD', which is specific about verb, resource, and scope. It also differentiates from sibling tools by noting the version is what create_k8s_cluster uses when k8s_version is omitted.

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 by explaining its role in the cluster creation flow, letting agents understand it's for querying the default rather than specific versions. It doesn't explicitly contrast with list_k8s_versions, but the practical context given is nearly complete.

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 include readOnlyHint: true, and the description adds that the tool returns specific fields (name, state, version, IPs), which is useful. However, it does not disclose additional behavioral aspects like response pagination or error conditions, but given the read-only nature, this suffices.

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 front-loads the primary purpose and key output details. No filler or redundant information, earning full marks.

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, the description explicitly lists return fields, covering the main expected data. It also implies required parameters via the resource hierarchy, though it could mention the three identifiers. Adequate for a simple read 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 coverage is 100%, with all parameters clearly described. The description adds no extra parameter detail beyond the schema but mentions output fields, which helps interpret the return, though not 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 tool's purpose: getting details of a specific worker node in a Kubernetes node pool, including name, state, version, and IPs. It distinguishes from sibling tools by specifying 'worker node' rather than cluster or nodepool.

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 its use case (fetching node details) but does not explicitly contrast it with sibling tools like get_k8s_cluster or list_k8s_nodepool_nodes. It provides no instructions on when not to use it, leaving the agent to infer based on resource type.

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 no contradiction. The description adds valuable context about how the returned data relates to update operations (list replacement) and availableUpgradeVersions, which is beyond the annotation and helps the agent understand the data'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?

Three concise sentences, each with purpose: listing details, providing crucial usage warning, and noting a specific output field. No redundant text; perfectly front-loaded.

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

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

For a read-only get operation with full schema coverage and no output schema, the description is highly complete. It covers what the tool returns, why it's useful (pre-update check), and mentions upgrade paths, leaving no major 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 100%, so parameters are fully documented. The description does not add extra parameter-level meaning beyond what's in the schema, but it does mention a returned field (availableUpgradeVersions) that clarifies the output. 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?

Clearly states it gets details of a specific Kubernetes node pool and enumerates the specific fields (node count, hardware, autoscaling bounds, LANs, labels, annotations). Distinguishes from the many sibling get_* tools by naming the resource and its 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?

Explicitly instructs to read this before calling update_k8s_nodepool for certain fields, and explains that those fields replace entire lists. Also mentions availableUpgradeVersions for version migration context, giving clear when-to-use 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 indicates this is a read operation, and the description merely restates that it 'gets details.' No additional behavioral context (e.g., authentication requirements, rate limits, or scoping constraints) is provided 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, front-loaded sentence with no unnecessary words. While it is very brief, it is not padded and clearly states the core 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 read operation with well-documented parameters, the description is minimally adequate. However, it lacks context about the relationship to datacenter_id and does not clarify what 'details' includes, which could be important given no output schema. The presence of sibling tools adds ambiguity that the description does not resolve.

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% (all three parameters have descriptions), so the schema already documents the parameters. The description adds no extra parameter semantics beyond what the schema provides, which aligns with 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 'Get details of a specific LAN' uses a clear verb and resource, and distinguishes itself from list_lans by indicating a single item ('a specific LAN'). However, it does not explicitly mention that the LAN is scoped by datacenter_id, which is a required parameter.

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 list_lans or list_lan_nics. The description does not offer any context for selection, but it is not misleading either.

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=true annotation and adds no conflicting information. It provides minimal contextual value beyond the annotation, as 'Get details' is essentially restating the operation name without additional behavioral insights.

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 is front-loaded and immediately understandable. Every word earns its place, and there is zero 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 getter with no output schema, the description is adequate but does not add extra context like the purpose of the depth parameter or any constraints on usage. Given the presence of similar sibling tools, a brief note on resource scope would have enhanced completeness.

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%, so the baseline is 3. The description adds no extra meaning about the parameters (depth, datacenter_id, loadbalancer_id) beyond what the schema already documents, but it is not required to do so given the thorough 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 tool retrieves details of a specific load balancer, using a specific verb and resource. However, it does not distinguish this 'loadbalancer' tool from closely named siblings like get_network_loadbalancer and get_application_loadbalancer, missing an opportunity for explicit differentiation.

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 the numerous sibling get/list load balancer tools. There is no mention of prerequisites, alternatives, or exclusions, leaving the agent to infer usage solely from the 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?

The annotation declares readOnlyHint: true, which already covers the safety profile. The description adds minimal behavioral context beyond that, just the purpose. It doesn't disclose anything about the response structure, potential errors, or pagination. With annotation coverage, the bar is lower, but the description still doesn't add meaningful behavioral details beyond what annotations imply, so a 2 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 that directly conveys the purpose. No filler or unnecessary words, and the structure is clear. It's 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 simple getter tool with full schema coverage and a read-only annotation, the description is sufficient to understand the tool's basic functionality. However, it doesn't mention any return value details (e.g., what fields are included) or edge cases (e.g., if the NAT gateway doesn't exist). Given the tool's simplicity(i.e., 3 params, no output schema), a 3 is fair as it meets minimum requirements but leaves some 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 100%, so the description doesn't need to add much. The parameters are all documented in the schema, and the description confirms the tool takes a datacenter and NAT gateway ID. It adds little beyond the schema, so baseline 3 is appropriate because the schema handles the parameter semantics.

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 the resource 'a specific NAT gateway', which matches the name and title. It distinguishes from siblings like list_nat_gateways (list all vs get specific) and get_nat_gateway_rules (rules vs gateway itself), though not explicitly. A score of 4 is fair because it lacks explicit differentiation from similar get_* tools.

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 this tool is for retrieving a single NAT gateway when you know its ID, but it does not explicitly state when to use it over list_nat_gateways or other alternatives. The context is clear enough for a simple getter, but there are no exclusions or alternative mentions, so it's decent but not thorough.

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 annotation readOnlyHint=true, indicating a read-only operation. It adds no extra behavioral context such as auth requirements, rate limits, or response format. The annotation already covers the key safety profile, so a score of 3 reflects the adequate but minimal extra info.

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 redundancy or filler. It front-loads the action ('Get') and the target, making it immediately 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?

For a simple get-by-ID tool, the description is adequately complete. It names the resource type and includes the NLB abbreviation. Combined with schema and annotations, an agent has enough to invoke it correctly. A small gap is not specifying what 'details' includes, but this is a minor omission for such a straightforward 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 coverage is 100%, with all three parameters (datacenter_id, network_loadbalancer_id, depth) described in the schema. The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline score of 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 uses the specific verb 'Get' and identifies the exact resource, 'details of a specific network load balancer (NLB)'. It clearly distinguishes from sibling tools like list_network_loadbalancers (which lists) and get_application_loadbalancer (which targets a different balancer type).

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

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

Usage context is implied: to retrieve details of a single NLB when you have its ID and the data center ID. However, there is no explicit guidance on when to choose this over alternatives like get_loadbalancer or get_application_loadbalancer, and no mention of prerequisites such as needing to list NLBs first.

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 signals read-only behavior, and the description merely confirms this with 'Get details' without adding new behavioral context. It does not contradict the annotation, but it also doesn't disclose anything about errors, depth parameter effects, or parent resource requirements. Minimal added value beyond the structured 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?

Nine words, front-loaded with the action and resource, and zero redundancy. Every word earns its place, and the parenthetical '(NIC)' removes any ambiguity. Perfectly proportioned 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 simple read-only getter with a 100%-covered schema and annotations, this is adequate. The term 'details' is vague, but since there is no output schema, the agent must infer what is returned. Could be improved by listing example NIC properties (IP, MAC, status), but not required for basic 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?

Schema coverage is 100% with clear descriptions for all four parameters (depth, nic_id, server_id, datacenter_id), so the baseline of 3 applies. The description adds no additional parameter context, but the schema already does the heavy lifting, making this acceptable.

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?

Clear 'Get details of a specific network interface (NIC)' with verb, resource, and scope, distinguishing it from list operations like list_nics. The word 'specific' signals singular resource retrieval by ID. Slightly generic in that 'details' could be more descriptive, but unambiguous in context.

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. With numerous sibling getters (get_server, get_datacenter, etc.) and list_nics as a complementary operation, an explicit mention of 'use when you have a NIC ID' would help. No exclusions or cross-references 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 discloses that the secret key is not returned, which is a critical behavioral detail beyond the input schema. With no annotations, this adds value by setting expectations for the response.

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, well-structured sentence that conveys purpose and a key behavioral constraint with no waste.

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 description covers the basic purpose and a critical behavioral aspect, it does not specify what 'metadata' includes (e.g., creation date, status). Without an output schema, the agent may need to infer the response structure, leaving some uncertainty.

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 a description for the only parameter (access_key_id), and the description does not add additional semantic detail beyond identifying the key by ID. Baseline 3 as schema coverage is 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 (Get details), the resource (specific Object Storage access key), and the method (by ID). It also distinguishes from the sibling 'list_object_storage_access_keys' by focusing on a single key.

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 that this tool is for retrieving a single key when the ID is known, contrasting with the list tool. However, it does not explicitly state when to use this vs. alternatives or provide 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?

No annotations provided, so description carries full burden. 'Get' implies read-only, but no mention of permissions, rate limits, or side effects. Adequate for a simple get operation but lacks 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?

One concise sentence with no fluff. 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?

Minimally complete for a simple get tool with one parameter. No output schema, but return value is implied. Could mention response format or error cases.

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?

Single parameter 'bucket' already has description in schema ('the name of the object storage bucket'). Description adds no new meaning beyond 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?

Clearly states verb 'Get', resource 'CORS configuration', and scope 'for an Object Storage bucket'. Differentiates from sibling tools like get_object_storage_bucket_encryption.

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 or when not to use. Many similar get_object_storage_bucket_* tools exist, but no context about CORS-specific 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 verb 'Get' clearly indicates a read-only, idempotent operation. No annotations are present, but the description's simplicity accurately portrays the tool's behavior. No contradictions or hidden 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?

A single sentence that is front-loaded with the purpose. No extraneous 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?

For a simple read operation with one parameter and no output schema, the description adequately conveys the tool's function. It implies the return value (the encryption configuration). Slightly more detail about what is returned would raise the 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?

Schema description coverage is 100% (parameter 'bucket' described in schema). The description does not add new parameter details beyond the schema, meeting the baseline expectation.

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 the server-side encryption configuration for an Object Storage bucket. The specific resource ('encryption configuration') distinguishes it from sibling tools like get_object_storage_bucket_cors or get_object_storage_bucket_lifecycle.

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, no prerequisites, and no mention of when not to use it. It simply states what it does.

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 present, so the description must carry the full burden of behavioral disclosure. It only states 'Get the lifecycle configuration' without mentioning read-only nature, permissions, error conditions, or return behavior. This is insufficient for an agent to understand the tool's complete behavior.

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 without extraneous information. It is well-structured but could benefit from additional details 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?

No output schema exists, so the description should explain the return value (the lifecycle configuration). It does not mention the format, structure, or any success/error conditions. For a simple tool with one parameter, the description is incomplete for agent comprehension.

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% coverage with a description for the 'bucket' parameter. The description adds no additional meaning beyond the schema, so it meets the baseline of 3.

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 the resource 'lifecycle configuration for an Object Storage bucket'. This distinguishes it from sibling tools like get_object_storage_bucket_cors or get_object_storage_bucket_encryption.

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, prerequisites (e.g., bucket must exist), or what happens when there is no lifecycle configuration. The description offers no context for selecting among many get_* 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?

With no annotations, the description carries full burden for behavioral disclosure. It only states 'Get the region/location' but does not mention whether this operation is read-only, requires authentication, has rate limits, or what happens on error. The description is insufficient for an agent to understand the tool's 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 a single sentence of 10 words, which is concise and front-loaded. However, it may be too terse, omitting important details. It is not verbose but could be slightly expanded without losing 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?

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is lacking. It does not describe the return value format (e.g., a string region code or a location object). For a complete invocation, the agent needs to know what the response looks like. The description leaves this 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% (the single parameter 'bucket' is described as 'the name of the object storage bucket'). The description adds no additional meaning beyond the schema. According to the rubric, baseline is 3 when coverage is high, and the description does not improve 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 clearly states the tool's purpose: 'Get the region/location of an Object Storage bucket.' The verb 'Get' and resource 'region/location' are specific and unambiguous. It distinguishes itself from sibling tools like 'list_object_storage_buckets' (which lists buckets) and 'get_object_storage_region' (which likely returns region metadata).

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. It does not mention prerequisites (e.g., bucket must exist), when to prefer this over other bucket info tools, or what to do if the bucket is not found. The agent is left without context for appropriate invocation.

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 provided, the description bears full responsibility for behavioral disclosure. It does not mention that the operation is read-only, whether special permissions are needed, or what happens if the bucket lacks a lock configuration.

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 unnecessary words. 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?

Given the low complexity (one parameter, no output schema), the description provides adequate but minimal context. It lacks expected return information or error conditions, which would improve completeness.

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%, and the description adds minimal value beyond stating 'Object Storage bucket'. The schema already describes the parameter similarly, so the description does not significantly enhance understanding of the parameter.

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 specific action (Get) and resource (Object Lock configuration for an Object Storage bucket). It directly distinguishes itself from sibling tools that retrieve other bucket configurations like CORS or encryption.

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, nor does it mention any prerequisites or scenarios where it should not be used. Given many similar sibling tools, this omission hampers correct 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, and the description does not disclose behavioral traits such as read-only nature, required permissions, or rate limits. It simply restates the operation.

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, concise sentence that is directly to the point with no unnecessary words. Ideal structure for quick understanding.

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 get operation without an output schema, the description is adequate but minimal. It does not explain the policy format or response structure, 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?

Schema description coverage is 100% (the one parameter 'bucket' is described as 'the name of the object storage bucket'). The tool description adds no additional meaning beyond the schema, 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 verb ('Get'), resource ('bucket policy'), and scope ('for an Object Storage bucket'). It is specific and distinguishable from sibling tools like get_object_storage_bucket_policy_status.

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 (e.g., get_object_storage_bucket_policy_status). The description does not mention exclusions or prerequisites.

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, and the description does not disclose behavioral traits such as read-only nature, required permissions, or side effects. It only states the basic purpose.

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

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

The description is a single concise sentence that immediately conveys the core function. No extraneous words or 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?

Given the single parameter, no output schema, and lack of annotations, the description is insufficient. It does not explain return values or behavioral nuances needed for complete understanding.

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 provides a description for the 'bucket' parameter, achieving 100% coverage. The tool's description does not add additional meaning beyond what the schema already 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 retrieves the policy status for an Object Storage bucket, specifically to indicate whether the bucket is public. This distinguishes it from sibling tools like get_object_storage_bucket_policy (full policy) and get_object_storage_bucket_public_access_block (access block settings).

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 lacks any guidance on when to use this tool versus alternatives. No context about prerequisites, when-not-to-use, or comparisons with sibling tools 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states it gets the configuration but does not mention auth requirements, side effects, or rate limits. The operation is read-only, but that is implicit.

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 and front-loaded. No unnecessary 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 simple GET operation with one parameter, the description is mostly complete. However, no output schema exists and the description does not indicate what is returned (e.g., configuration structure), but the tool's purpose is clear enough.

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 already describes the 'bucket' parameter succinctly. The description does not add extra meaning beyond referencing the bucket. With 100% schema coverage, 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 verb 'Get' and the specific resource 'public access block configuration for an Object Storage bucket'. It distinguishes itself from sibling tools like get_object_storage_bucket_policy or get_object_storage_bucket_cors.

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 other get_* tools for the same bucket (e.g., get_object_storage_bucket_policy). There are no when-not conditions or alternative suggestions.

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 'Get', implying a read-only operation, but does not disclose any behavioral traits such as error handling (e.g., returns 404 if bucket doesn't exist), prerequisites, or the format of the returned configuration. This is minimal transparency for a tool with no 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, concise sentence that immediately conveys the tool's purpose. It is front-loaded with the key action and object, with no extraneous words. 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?

The tool is a simple getter with one parameter and no output schema. The description covers the basic purpose, but given the presence of many sibling tools for different bucket configurations, it could be more complete by specifying what the replication configuration includes or how it differs from other configurations. It is adequate but not 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 100% (one parameter 'bucket' with a clear description). The tool description does not add any meaning beyond the schema; it simply restates 'the name of the object storage bucket'. According to the guideline, baseline is 3, and no extra value is provided, so score remains 3.

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 gets the replication configuration for an Object Storage bucket. The verb 'Get' and resource 'replication configuration' are specific, distinguishing it from siblings like get_object_storage_bucket_encryption or get_object_storage_bucket_versioning. However, it lacks additional context that would make it a 5, such as scope or constraints.

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 similar getters for different bucket configurations (e.g., CORS, lifecycle, policy), and the description does not help the agent decide which one to invoke. It does not mention when not to use it or provide any selection 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 carries full burden. It fails to disclose behavioral traits such as whether the bucket must exist, what happens if no tags are set, or permission 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?

A single, clear sentence with no unnecessary words or fluff. Efficiently communicates the tool's core action.

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

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

The description lacks details about the return format (e.g., key-value pairs of tags) and error handling, which would be helpful given the absence of an output schema. Adequate but incomplete for a simple 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 input schema has 100% description coverage for the only parameter 'bucket'. The description adds no additional meaning beyond the schema, meeting the baseline expectation.

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 the verb 'Get' and the resource 'tags for an Object Storage bucket', clearly distinguishing it from sibling get_object_storage_bucket_* tools that target other bucket properties.

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 (e.g., other get_object_storage_bucket_* tools). No prerequisites or when-not-to-use conditions 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 does not state that the operation is read-only, describe side effects, indicate permissions required, or specify error conditions (e.g., if the bucket does not exist).

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, 9 words, front-loaded with the key action and resource. Every word earns its place; no wasted text.

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 minimal description, the agent lacks information about what the response contains (e.g., versioning status values), preconditions, or how to interpret results. This is insufficient for a complete understanding.

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 'bucket' has a description). The tool description adds no additional meaning beyond the schema, 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 'Get the versioning configuration for an Object Storage bucket' clearly states the verb (get), resource (versioning configuration), and object (bucket). It distinguishes itself from sibling 'get_object_storage_bucket_*' tools by specifying which configuration it retrieves.

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 'list_object_storage_buckets' or other bucket configuration getters. There is no mention of prerequisites, context, or when not to use it.

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

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

With no annotations, the description must disclose behavioral traits. It only states it 'gets' status, but doesn't disclose any side effects, permissions needed, or error conditions (e.g., legal hold not configured). Minimal 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 with no wasted words. However, it is very brief and could benefit from additional context without sacrificing 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 tool with no output schema and two well-described parameters, the description is adequate but minimal. It does not explain the return format or behavior if legal hold is unset, leaving some 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 100% with clear descriptions for both parameters. The description adds no additional meaning beyond the schema, so 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 specifies the verb 'Get' and the resource 'Object Lock legal hold status for an object in an Object Storage bucket'. It is specific and distinguishes from sibling tools like 'get_object_storage_object_retention'.

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 vs alternatives, nor does it mention prerequisites or exclusions. It lacks explicit context for selection among similar 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, the description does not explicitly state that it is non-destructive or whether it requires specific permissions. It also does not disclose any side effects or error conditions. The description adds minimal transparency 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 a single concise sentence that immediately conveys the purpose. There is no verbosity; every word is necessary and informative. It is optimally sized for a simple retrieval operation.

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 low complexity, two well-described parameters, and no output schema, the description is adequate but not comprehensive. It does not explain what the retention configuration includes (e.g., mode, retain until date) or how the response will look. For a tool with no output schema and no annotations, a bit more detail would improve completeness.

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 both parameters (bucket and key) having descriptions in the schema. The description does not add any additional meaning or context beyond what the schema already provides. Therefore, the description does not compensate for or enhance the parameter semantics. 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 clearly states the action ('Get') and the specific resource ('Object Lock retention configuration') and scope ('for an object in an Object Storage bucket'). It effectively distinguishes from sibling tools like get_object_storage_bucket_lock_configuration (bucket-level) and get_object_storage_object_legal_hold (legal hold vs retention) by specifying 'retention configuration'.

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. It does not mention prerequisites, such as whether the bucket must have Object Lock enabled, nor does it indicate when not to use this tool (e.g., for bucket-level retention settings). No comparison with sibling tools 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?

No annotations are provided, so the description must fully disclose behavioral traits. It only states 'Get', implying a non-destructive read, but fails to explicitly mention idempotency, authentication requirements, rate limits, or that no side effects occur.

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 unnecessary words. It is front-loaded with the action and clearly direct.

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 lack of an output schema, the description does not explain the return format (e.g., a dictionary of tags). It also omits prerequisites like the bucket and object existing. However, for a simple get operation, it provides adequate core 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% with descriptions for 'bucket' and 'key'. The description adds no additional meaning beyond the schema, which already defines the purpose of each parameter. 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 clearly states that the tool retrieves tags for an object in an Object Storage bucket, using a specific verb 'Get' and resource 'tags for an object'. This distinguishes it from the sibling tool 'get_object_storage_bucket_tagging' which operates on the bucket itself.

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., 'get_object_storage_bucket_tagging' for bucket-level tags). It does not include any conditions, 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?

No annotations provided. The description only says 'Get details' without specifying what details are returned, side effects, or authentication requirements. Minimal behavioral transparency.

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

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

One short, front-loaded sentence with no unnecessary words. Perfectly 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?

Given a simple tool with one parameter and no output schema, the description is adequate but minimal. It does not explain what the returned details include, which might be useful for an agent. Not incomplete, but could be better.

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%, and the description repeats the example from the schema. It adds the example 'eu-central-3' for clarity, but does not add significant new 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 it gets details of a specific Object Storage region, using a precise verb and resource. It distinguishes from sibling list_object_storage_regions, which lists all regions.

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 you need a region name but lacks explicit guidance on when to use this vs list_object_storage_regions. No alternatives or context 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?

The readOnlyHint annotation already signals a safe read operation, and the description is consistent with that. However, the description adds no further behavioral context beyond what the annotation and schema provide, such as what exactly 'details' includes or any pagination/error behavior.

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, and efficient sentence. It contains no redundant wording and immediately communicates 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 simple read-only getter with one required parameter and no output schema, the description is adequate. It clearly indicates the tool fetches details of a single resource. It does not explicitly mention what fields are returned, but this is not required given the lack of output schema and the straightforward nature of the 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%, so both parameters (pcc_id and depth) are already documented. The description does not add extra meaning or clarify parameter usage 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 the specific verb 'Get' with the resource 'private cross-connect' and clarifies it's for a specific instance, which clearly distinguishes it from the sibling tool list_private_cross_connects. It accurately conveys that this is a single-resource retrieval operation.

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 context is implied by the pattern: use this when you have a pcc_id and need details for one cross-connect, as opposed to listing all. However, there is no explicit guidance on when to use this tool versus alternatives like list_private_cross_connects, leaving the agent to infer the appropriate use case.

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 aligns with the readOnlyHint annotation, but adds little behavioral context beyond the resource scope. It does not mention response format, potential errors, or any special behavior, though the annotation already covers the read-only nature.

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 conveys the tool's purpose without unnecessary words. It is well-structured 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?

For a simple get-by-id tool, the description is adequate but not rich. There is no output schema, and the description does not clarify what 'details' includes or how it differs from 'get_request_status', leaving some ambiguity for 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 input schema fully documents both parameters ('request_id' and 'depth') with descriptions, so the description adds no semantic value beyond what is already in the schema. Baseline of 3 applies due to 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 clearly states the verb ('Get details') and the resource ('specific API request'), making it clear what the tool does. However, it does not explicitly differentiate from the sibling tool 'get_request_status', which could be confused with this one.

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 retrieving details of a single request but provides no explicit guidance on when to use this tool versus 'list_requests' or 'get_request_status'. No alternatives or exclusions 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?

The annotation readOnlyHint=true aligns with the description's 'Get' action, so no contradiction. The description does not add any behavioral details beyond the annotation, such as the effect of the optional 'depth' parameter or any rate limiting/auth requirements. With the annotation covering safety, a baseline score 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, precise sentence with no redundant words or filler. It is optimally concise and front-loaded, capturing the tool's core function 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 simple status retrieval tool, the description is minimally sufficient given the complete schema and readOnlyHint annotation. However, it does not explain what 'status' means, potential return values (no output schema), or how 'depth' affects results. This leaves some ambiguity for an agent deciding on 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 100%, with 'request_id' and 'depth' both described. The description adds no extra meaning about these parameters; it only mentions 'specific API request' without elaborating on depth or request ID format. Since the schema already handles parameter documentation, the baseline of 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 tool retrieves the status of a specific API request. The verb 'Get' and resource 'status' make the purpose unambiguous. However, it does not differentiate from sibling 'get_request' which might return full request details, so it misses explicit sibling distinction.

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 given about when to use this tool versus alternatives like 'get_request' or when to prefer 'list_requests'. There is no mention of context, prerequisites, or scenarios where this status-specific 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, so the safety profile is known. The description adds no behavioral context beyond what the annotation implies—no mention of return format, nesting behavior via depth, or any side effects. It is a bare statement that repeats the tool's function without adding 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 sentence that is concise and front-loaded. It communicates the essential purpose without any 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 simple single-resource getter with a full schema and read-only annotation, the description is adequate. It does not describe the return value, but the operation is straightforward and the parameter schema is complete, so the agent can infer expected behavior. Slight deduction due to lack of explicit mention of which details are returned.

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%, so all three parameters (depth, datacenter_id, security_group_id) are already described in the input schema. The description does not add any additional meaning beyond the structured data, thus it aligns with the baseline of 3 for full 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 clearly states the action ('Get details') and the target resource ('a specific security group'). It distinguishes itself from list_security_groups by emphasizing specificity, and from get_security_group_rule by focusing on the group itself.

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 by requiring a specific security_group_id, but does not explicitly mention when to prefer this over list_security_groups or get_security_group_rule. No alternative tools are named. The word 'specific' gives some guidance but no explicit when/when-not.

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, adding no contradiction. However, it provides no additional behavioral context beyond 'Get details', such as not-found behavior, return structure, or required permissions. With the annotation covering safety, the description meets the minimum expected value.

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, complete sentence with no wasted words. 'Get details of a specific security group rule' is concise, front-loaded, and immediately conveys 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?

Given the simple get-by-ID operation, complete schema descriptions, and read-only annotation, the description is adequate for an agent to invoke the tool. It lacks only explicit guidance on related list/get alternatives, but the core operation is well-defined.

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 (datacenter_id, security_group_id, rule_id, depth) already documented in the schema. The tool description adds no semantic context about how these parameters relate, so it does not exceed the baseline for full 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 uses a specific verb ('Get') and resource ('security group rule') with the modifier 'specific', clearly distinguishing it from sibling tools like list_security_group_rules and get_security_group. It precisely identifies the object of the operation.

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 a single security group rule's details are needed, but it does not explicitly state when to use this tool versus alternatives. No mention is made of list_security_group_rules for listing or when not to use this tool.

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

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

The readOnlyHint annotation already communicates this is a safe read operation, and the description aligns with that. The description adds no behavioral context beyond the annotation, such as return shape, depth behavior, or any side effects, but also does not contradict 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, focused sentence with no filler or redundant detail. It states the operation directly and 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?

For a simple read-only get operation with a well-specified schema and a readOnlyHint, the description is minimally viable. However, it provides no details about the return value, the role of the datacenter_id, or the meaning of the optional depth parameter, leaving some context undisclosed.

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% parameter description coverage, so the schema carries the needed parameter semantics. The description adds no additional meaning to the 'datacenter_id' or 'server_id' parameters beyond the generic 'specific server' idea.

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

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

Description uses a specific verb and resource ('Get details of a specific server') that clearly identifies a single-server retrieval operation. It distinguishes itself from list_servers and related per-server tools like get_server_gpu, though it doesn't explicitly differentiate those sibling tools.

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 given about when to use this tool versus alternatives such as list_servers or get_server_remote_console. The phrase 'specific server' implies single-resource retrieval, but there is no stated when/when-not logic or alternative tool naming.

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 read-only behavior. The description adds no additional behavioral context like error cases, prerequisites, or side effects, so it provides minimal value 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 sentence with no filler, front-loaded with verb and resource. It efficiently conveys the core 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 getter with no output schema, the description gives the essential purpose but lacks detail about what 'details' are returned. Given the absence of an output schema, a bit more specificity about the response could be expected, but it's acceptable for a straightforward read 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 has 100% description coverage for all 4 parameters. The description does not elaborate on parameter meanings or relationships beyond the schema, so it matches 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?

Description clearly states the action (Get) and specific resource (details of a GPU attached to a server). It distinguishes from siblings like get_server or list_server_gpus by specifying the GPU 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 implicitly conveys it's for fetching details of a single GPU, but does not explicitly contrast with list_server_gpus or state when not to use. It's clear enough for the intended use case.

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 establishes this as a safe read operation. The description adds that the tool returns a URL, but does not disclose any additional behavioral traits such as whether the server must be running, whether the URL is temporary, or any error conditions. With annotations present, the bar is lower, but the description contributes minimal extra context beyond the purpose.

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. Every word earns its place, 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?

For a simple read-only getter with two required parameters and no output schema, the description adequately conveys the return value (a URL). It does not mention error cases or prerequisites, but the tool's simplicity and the schema's full parameter documentation make the description sufficient for basic invocation.

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

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

Schema description coverage is 100%, with each parameter (server_id, datacenter_id, depth) already documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, 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 ('remote console URL') with a clear scope ('for a specific server'). It clearly distinguishes from sibling tools like get_server (which retrieves server details) and get_server_gpu (GPU-specific info).

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 the remote console URL is needed for a server, but provides no explicit when-to-use or when-not-to-use guidance, nor does it name alternatives. It is a simple getter, but the lack of any differentiation from the many sibling get_* tools leaves the agent to infer 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 readOnlyHint annotation already signals a safe read operation, and the description does not contradict it. The description adds minimal context ('specific snapshot' scoping) but does not elaborate on behavior such as error handling, return format, or how depth affects the response.

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 directly communicates the tool's purpose with zero wasted words or redundant 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?

For a simple two-parameter read operation with a readOnlyHint annotation, the description is sufficient to select and invoke the tool. While there is no output schema and the description doesn't elaborate on return values, the tool's function is straightforward enough that this is not a critical 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 input schema provides 100% coverage with descriptions for both snapshot_id and depth, so the baseline is 3. The description adds no additional meaning beyond what the schema already states, and does not compensate for any gaps.

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 'Get details of a specific snapshot' uses a specific verb ('Get') and resource ('snapshot'), clearly distinguishing it from list_snapshots and other get_* tools for different resources. It unambiguously states the tool's function.

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?

Usage is implied by the word 'specific' — the tool is for retrieving a known snapshot by ID. However, there is no explicit guidance about when to use this versus list_snapshots or other alternatives, and no exclusions 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?

The annotations declare readOnlyHint: true, so the read-only nature is already covered. The description adds no extra behavioral insight, such as what fields are returned, whether it raises errors for non-existent IDs, or how the depth parameter affects the response. It is not misleading, but it does not go 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 concise sentence ('Get details of a specific target group') with no redundancy or wasted words. It is front-loaded and immediately clear about 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?

Given the simple parameter set (2 params, 1 required), the lack of an output schema, and the presence of a read-only annotation, the description is minimally sufficient. However, it does not clarify what 'details' includes or whether nested objects are returned unless depth is specified—information that would improve 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?

Schema description coverage is 100%—both target_group_id and depth have descriptions in the input schema. The tool description does not add any meaning beyond what the schema provides, so the baseline of 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 'Get details of a specific target group' uses a clear verb ('Get') and resource ('target group'), and the word 'specific' indicates it retrieves a single entity by ID, distinguishing it from list_target_groups. It is straightforward and aligned with sibling get_* tools, though it does not explicitly name alternatives.

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 (you need a target_group_id to fetch one specific group), but it does not explicitly state when to use this tool versus list_target_groups or any other alternative. No exclusions or prerequisites are mentioned beyond the required parameter.

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 establishes safety; the description adds nothing about response format or depth behavior. It is minimal but consistent with a read operation. There's no contradiction, but the description does not disclose what 'details' include.

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, no waste, front-loaded with the key 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 get-by-ID tool with full schema parameter descriptions and readOnlyHint, the description is adequate but could mention the required ID and depth parameter behavior more explicitly. It also doesn't specify what 'details' includes, though schema coverage mitigates this.

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?

Both parameters are fully documented in the schema (template_id and depth), and the description adds no extra meaning. With 100% schema coverage, the baseline of 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 'Get details of a specific server template' clearly states the action (get), the object (server template), and that it targets a specific instance via ID. It unambiguously distinguishes from list_templates in the sibling tools.

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 others, nor any prerequisites (e.g., needing to first call list_templates to obtain a template_id). For a get-by-ID operation, stating that the ID comes from list_templates would be helpful but is absent.

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 establishes that this is a safe read operation, and the description's 'Get details' aligns with that. The description adds no extra behavioral context such as error cases, authorization requirements, or return format, but does not contradict 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, front-loaded sentence with no filler or redundant phrasing. Every word earns its place, and it is appropriately sized for a straightforward 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 simple get-by-ID tool with full schema coverage and a read-only annotation, the description is minimally viable. However, with no output schema, it does not clarify what 'details' are returned, and it omits guidance on how the datacenter_id and volume_id relate to each other.

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%, so the parameters are fully documented in the input schema itself. The description adds no additional parameter guidance, matching the baseline expected when the schema carries the burden.

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+resource pattern ('Get details of a specific volume'), clearly distinguishing this tool from list_volumes and other getters. The word 'specific' communicates that this is a single-resource lookup by ID rather than a listing operation.

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: call this when you need details for a known volume. However, it does not explicitly say when to prefer this over list_volumes or mention how to obtain the required IDs, leaving the guidance to inference.

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 only states the purpose (check existence and accessibility) but does not describe the return value, error behavior, or idempotency. The agent is left uncertain about the output format.

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 front-loads the purpose. It is efficiently sized but may be too brief to convey necessary behavioral details. Still, it avoids fluff.

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 param, no output schema, no annotations), the description should provide enough context about the return value or success criteria. It does not mention what the agent should expect (e.g., success vs error, response data). This gap makes it 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?

Schema coverage is 100% (only one parameter 'bucket' described as 'the name of the object storage bucket'). The description adds no additional parameter context beyond what the schema provides, so it meets the baseline of 3.

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 checks if an Object Storage bucket exists and is accessible, using a specific verb and resource. It distinguishes from sibling tools like 'get_object_storage_bucket_*' (which retrieve specific configurations) and 'list_object_storage_buckets' (which lists all 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?

No usage guidelines are provided. The description does not specify when to use this tool versus alternatives (e.g., as a quick existence check before more detailed operations). It lacks context for the agent to decide appropriate invocation.

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 discloses key behaviors: returns error if object does not exist or is not accessible, and retrieves user-defined metadata. It does not mention other possible responses but covers the main purpose.

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 sentences, no redundant words. The essential information is front-loaded.

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