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

Beyond the openWorldHint/destructiveHint annotations, the description discloses concrete behavior: JSON output forced via `--cli-output=json`, destructive verbs listed explicitly (Delete, Remove, Revoke, Detach), dry-run-by-default with confirm=true to execute, OBS plain-text output, and the split between OBS commands supporting `-dryRun` (cp, mv, sync) versus those refused without confirmation (rm, abort, mb, chattri, bucketpolicy, lifecycle). This is substantial context an agent cannot get from annotations alone.

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 long but front-loaded and structured: a one-line identity, then two numbered discovery/execution ladders, then a short destructive-behavior paragraph. Every section carries operational content; the enumerations of destructive OBS commands and verbs are dense but earn their space by defining confirmation requirements.

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 correctly compensates by stating that CLI output is forced to JSON while OBS output is plain text. It also covers confirmation semantics for both subsystems. Remaining gaps are the routing question against specialized siblings and any statement about output size, pagination, or error surface for arbitrary CLI calls.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning: the parameter format is always `--param=value` with an equals sign required, `--cli-region` is translated into an OBS endpoint automatically, and confirm=false triggers `--dryrun` rather than a plain refusal for most commands. These format and translation rules are not derivable from the two-parameter schema alone.

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

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

The description names a specific resource and mechanism: a generic `hcloud`/`obs` CLI passthrough with a documented `--help` discovery ladder and `--param=value` execution form. It is clear what the tool does, but it never contrasts itself with the ~130 purpose-built `hcloud_list_*`/`hcloud_show_*` siblings, so an agent cannot tell from this text why it should pick the generic CLI over a dedicated 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?

It gives excellent *how* guidance (four-step help discovery, OBS equivalent, required equals-sign syntax) and states the confirmation rule for destructive commands. What is missing is *when* guidance: nothing says this is the fallback for operations lacking a dedicated tool, nor when the specialized siblings should be preferred. Usage is only implied by the tool's generality.

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, idempotentHint, and openWorldHint. The description adds only the distinction that these are 'installed' add-ons, not available ones, and that they belong to a CCE cluster. It does not disclose pagination, sorting, auth requirements, or return shape, so the extra context is modest.

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 definition is a single front-loaded sentence with zero filler. It states the action and scope immediately and contains no redundant or hedging language.

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 list operation with full schema coverage and read-only annotations, the description is nearly complete. It could mention pagination or the shape of the listing, but no output schema exists and the tool complexity is low, so the remaining gap is minor.

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 schema provides both required parameters. The description adds no meaning beyond that: it does not explain region or cluster_id semantics, and the schema descriptions are minimal ('Region', 'Cluster ID'). The baseline 3 applies when the schema carries the parameter documentation.

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 and resource: 'List installed add-ons in a CCE cluster.' It is clearly distinct from sibling tools about clusters, nodes, or node pools. It stops short of explicitly differentiating from a dedicated add-on listing alternative, which does not exist in the siblings, so a 4 rather than 5.

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 only implied by the resource scope: an agent would use this when it needs installed add-ons for a CCE cluster. There is no explicit when-to-use guidance, no exclusions, and no named alternative for related queries such as listing available add-ons.

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, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds only a definition of the resource and says nothing about result volume, pagination, or whether listings span the whole account or a single domain/project.

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 six-word fragment with the verb and resource front-loaded and zero filler. It is efficient, though the fragment form leaves room for one clarifying clause about scope.

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

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

For a zero-parameter read-only list tool with full annotation coverage, this is close to sufficient, and the 'trust relationships' gloss genuinely helps. What is missing is any hint of the listing scope (account vs. domain vs. project) or output shape, which matters in a catalog this large.

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 takes zero parameters, so the schema bears no explanatory burden and the description has no parameter semantics to compensate for. Baseline 4 applies.

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

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

States a specific verb (List) and resource (IAM agencies), and the parenthetical 'trust relationships' disambiguates an otherwise obscure term. It does not, however, distinguish this from nearby IAM siblings such as hcloud_list_users, hcloud_list_groups, or hcloud_list_policies.

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 reach for this tool versus the many other IAM list tools in the sibling set, and no stated preconditions or scope. The agent must infer that 'agencies' are IAM identity-provider trust relationships on its own.

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, idempotentHint=true, and openWorldHint=true, so safety behavior is covered. The description adds only that this hits the v2 API and returns 'more complete' data, with no word on pagination despite a limit parameter, result size, or ordering.

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 short clause with no wasted words and the resource front-loaded. It is terse rather than padded, though the terseness borders on under-specification handled elsewhere.

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 list tool in a dense namespace with an obvious near-duplicate sibling (hcloud_list_alarms), the description does not give the agent enough to choose correctly or to predict result shape. The full schema and annotations carry most of the weight, but the sibling-disambiguation gap is significant.

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 (limit, region) are documented in the schema and the baseline is 3. The description adds no meaning about region scoping, pagination defaults, or what limit applies to, so it does not exceed that baseline.

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 verb 'List' plus resource 'CES alarm rules' is specific enough to know what is returned, but the qualifier '(v2 API, more complete)' is ambiguous — it never says what it is more complete than, and there is a sibling hcloud_list_alarms whose relationship to this tool is left entirely implicit.

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 explicit when-to-use or when-not-to-use guidance. The parenthetical hint implies this is a newer/preferred listing, but an agent must infer whether to call this instead of hcloud_list_alarms, or whether both should be called.

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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. Beyond expanding 'CES' to 'Cloud Eye', the description adds nothing: it does not say whether results are region-scoped, whether alarm state/severity is included, or how pagination behaves with 'limit'.

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?

Four words, front-loaded with the verb and resource, with zero filler. It is efficient, though the brevity edges toward under-specification rather than crispness.

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 two-parameter read-only list tool with full schema coverage and annotations supplying the safety profile, an output schema is not needed and the core call path is intact. The remaining gap is disambiguation from hcloud_list_alarm_rules, which the description never addresses.

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 'region' and 'limit' are already documented in the schema, which sets the baseline at 3. The description adds no meaning beyond that, such as whether region is required for multi-region accounts or what the default limit is.

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 pairs a specific verb ('List') with a specific resource ('CES (Cloud Eye) alarms') and expands the acronym, so the object is identifiable. However, the sibling set contains hcloud_list_alarm_rules, and nothing here distinguishes an alarm from an alarm rule, leaving the agent unable to pick between the two without outside knowledge.

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, no exclusions, and no reference to any alternative such as hcloud_list_alarm_rules or hcloud_show_metric_data. The agent must infer usage context entirely 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds only the ECS scope; it says nothing about error behaviour for an invalid region, whether zones are region-scoped at all, or what the response contains.

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 six-word sentence with the service scope in the right place and no filler. It is terse but not padded or rambling.

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 and no annotations explaining return shape, the description should at least indicate that it returns a set of zone identifiers tied to the supplied region. For a discovery helper whose output feeds other calls, this is under-explained.

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

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

There is a single parameter with 100% schema description coverage, so the schema already documents the one input. The description does not add format examples, case sensitivity, or how region names map to availability zone identifiers, 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?

"List availability zones for ECS" gives a specific verb (list) and resource (availability zones) and scopes it to the ECS service, which distinguishes it from hcloud_list_dcs_available_zones. It stops short of explaining what an availability zone means in this cloud, but the operation is identifiable.

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 call this versus alternatives, whether the region must already exist, or what the result is used for (e.g., selecting a region for a later ECS create call). The agent must infer all of that 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered without description help. The description adds nothing beyond that: no indication of pagination behaviour, whether results span regions, or what 'limit' defaults to. No contradiction with annotations, but zero added 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?

Two words, but the brevity reflects under-specification rather than economy — there is no structure, no front-loaded scope, and no sentence that carries information beyond the title. Nothing is wasteful because there is almost nothing there.

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 two-parameter list tool with no output schema, the description should at least identify the resource domain and result shape. It leaves the agent guessing what a 'bandwidth' object is and whether region narrows the listing, which is inadequate even 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 description coverage is 100% (region: 'Region', limit: 'Max results'), so the baseline of 3 applies. The description contributes no additional meaning to either parameter — it does not clarify the region format, whether region is mandatory in practice, or how limit interacts with paging.

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?

"List bandwidths" restates the tool name with a verb and a resource noun but gives no scope: it does not say whose bandwidths (shared EIP bandwidths, per-region quotas, etc.), nor how this differs from any of the ~100 sibling list tools. An agent cannot distinguish it from hcloud_list_public_ips or hcloud_list_eip_quotas based on the description alone.

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 when-to-use guidance, no alternatives named, no prerequisites or exclusions. The only inferable usage is 'call it when you want bandwidths', which is a restatement of the name. With so many near-neighbour tools (public IPs, EIP quotas), the missing routing guidance is a real gap.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — no mention of pagination defaults, result ordering, or how the open-world remote lookup behaves for an agent.

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 front-loaded sentence with zero waste and no filler. It is appropriately sized for what it says, though the brevity leaves several gaps unaddressed.

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 three optional parameters and no output schema, the description leaves the return shape, pagination semantics, and status filter values unexplained. For a simple read-only list tool this is minimally adequate, but it does not fully carry the burden left by the absent output schema.

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

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

Schema coverage is 100%, with limit, offset, and status each documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond the schema, and notably gives no hint about valid status values, which are not enumerated.

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 and resource ('List ... customer orders') and expands the BSS acronym, so the domain is unambiguous. It does not differentiate from the nearest siblings (hcloud_list_bss_measurements, hcloud_show_bss_account_balance), though the distinct resource names make confusion unlikely.

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, when not to, or what alternative to reach for. An agent must infer that this is the paginated list operation for BSS orders purely from the name and the limit/offset 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 annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds only the acronym expansion and does not explain what a BSS measurement represents, what is returned, or any pagination behavior 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 front-loaded sentence with no wasted words. It is appropriately sized for a simple list tool, though it is so terse that it omits helpful routing context.

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

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

For a tool that must be distinguished from many sibling list/show tools, the description is incomplete: it does not clarify what BSS measurements are or how they relate to customer orders and account balance. The annotations reduce the behavioral burden, but the agent still lacks enough context to confidently select this tool over siblings.

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

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

Schema description coverage is 100% for the two pagination parameters, so the schema already defines limit and offset clearly. The description does not add any meaning beyond the schema, which meets the baseline of 3 when the schema carries 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 specific verb (List) and resource (BSS measurements), and expands the acronym to Billing and Subscription, which helps an agent understand the domain. It does not distinguish this tool from sibling BSS tools such as hcloud_list_bss_customer_orders or hcloud_show_bss_account_balance.

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 explicit guidance on when to use this tool versus the other BSS siblings. The usage is only implied by the tool name; no exclusions or alternative conditions 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 annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, covering the safety profile. The description adds no behavioral context beyond the title: it does not mention pagination behavior, the required region, filtering options, or what the listing returns.

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 wording. However, it is extremely sparse and provides no structural cues about required region, filtering, or pagination behavior.

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 five-parameter list tool with no output schema, the description is minimal. The schema covers parameter semantics and annotations cover safety, but the description still omits the required region, pagination, and how CBR backups relate to sibling CBR vaults and policies.

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 all five parameters (including the required region) are documented in the input schema. The description adds no meaning beyond the schema, 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 states a specific verb ('List') and resource ('CBR (Cloud Backup and Recovery) backups'), and expands the acronym clearly. It does not distinguish this from sibling tools such as hcloud_list_cbr_vaults, hcloud_list_cbr_policies, or hcloud_list_rds_backups, so sibling differentiation is absent.

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 when-to-use guidance, no alternative tool named, and no prerequisites or exclusions stated. The description only says what the tool does, leaving the agent to infer when to choose it over related CBR or backup list tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is fully covered without the description. Beyond expanding the acronym, the description adds no behavioral context: it says nothing about pagination behavior, default page size, or ordering of results, which matters for a list tool with limit/offset.

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 front-loaded sentence with zero padding. It is efficient, though its brevity borders on under-specification rather than deliberate 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?

With full schema coverage and read-only annotations, the definition is minimally sufficient to call the tool. However, for a paginated list tool in a family with several CBR siblings, it leaves the agent without scope or routing guidance.

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

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

Schema description coverage is 100%, so limit, offset and the required region are already documented in the schema. The description adds no meaning beyond that, 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?

States a specific verb ('List') and resource ('CBR backup policies') and expands the CBR acronym, so an agent knows exactly what is returned. It does not distinguish itself from close siblings such as hcloud_list_cbr_vaults or hcloud_list_cbr_backups, which is the only thing keeping it from a 5.

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 when-to-use guidance, no mention of the sibling list tools for vaults or backups, and no stated prerequisite such as needing a region first. The agent must infer scope entirely 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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered by structured data. The description adds nothing beyond that: it does not say how pagination behaves, whether the region parameter narrows results, or what identifying fields each vault entry carries.

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 front-loaded sentence with no filler or redundancy. It is efficient, though the space saved is not used for any disambiguation that would help selection.

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 three-parameter read-only list tool with a fully documented schema and no output schema, this is minimally sufficient. It stops short of telling the agent how to scope results by region or what a returned vault looks like, which would matter when choosing between this and hcloud_show_cbr_vault.

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 (limit, offset, region) described inline, so the schema carries the semantics. The description adds no extra meaning, such as whether region is mandatory or how limit/offset interact, which is the expected baseline when the schema is fully documented.

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 gives a specific verb ('List') and resource ('CBR vaults') and expands the CBR acronym, so an agent knows exactly what collection is returned. It does not, however, distinguish this from the sibling hcloud_show_cbr_vault (single vault) or the adjacent hcloud_list_cbr_backups / hcloud_list_cbr_policies collections.

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 when-to-use guidance and no mention of alternatives; an agent must infer from the name alone that this lists vaults rather than fetching one vault or listing backups/policies. No prerequisites (e.g. that a region must be supplied to scope results) are stated.

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, openWorldHint and idempotentHint, and the description adds nothing beyond them — no note about pagination, region scoping behavior, result size, or what an empty result means. For a read-only list tool with full annotation coverage the bar is lower, but this adds zero behavioral context.

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

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

Five words, front-loaded with the verb and resource, and no wasted phrasing. It is arguably over-terse rather than padded, but as raw conciseness it is efficient.

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

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

For a simple two-parameter read-only lister with a fully described schema, the essentials are covered by the structured fields. However, with no output schema there is no explanation of what a cluster entry contains, and there is no hint about the required region's role, leaving small 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 region and status parameters are already documented, including example status values. The description mentions no parameter at all, so it neither compensates nor detracts; 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?

States a specific verb and resource ("List ... clusters") and expands the CCE acronym as Kubernetes, so the agent knows what is being enumerated. It does not distinguish itself from siblings such as hcloud_list_cce_nodes or hcloud_show_cce_cluster, so a 4 rather than a 5.

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 when-to-use guidance: nothing says to call this instead of hcloud_show_cce_cluster when full details are needed, or instead of hcloud_list_cce_nodes for node inventory. The only implied context is that it is a list operation.

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, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing beyond that: no mention of pagination, result volume, filtering, or what a node record contains, so it contributes essentially no behavioral context of its own.

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 front-loaded sentence with zero filler or redundancy. It is efficient, though the brevity reflects under-specification rather than disciplined economy.

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?

There is no output schema, so the description should carry the burden of explaining what comes back, pagination behavior, and how region and cluster_id relate to the returned nodes. None of that is present, leaving the tool under-described for an agent that needs to call it correctly.

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

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

Schema description coverage is 100% and both parameters are required, so the baseline of 3 applies. The schema descriptions are bare labels ('Region', 'Cluster ID'), and the description adds no format, sourcing, or scoping detail beyond them.

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 gives a specific verb and resource ('List nodes') scoped to a CCE cluster, which is enough to distinguish it from cluster-level or node-pool-level siblings in principle. However it never names hcloud_list_node_pools or hcloud_list_cce_clusters, so the boundary between 'nodes', 'node pools' and 'clusters' is left to the agent to infer.

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 when-to-use guidance: no statement of prerequisites (an existing cluster, valid region scope), no exclusions, and no reference to alternatives such as hcloud_show_cce_cluster or hcloud_list_node_pools. The agent must infer the call context purely 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered without the description's help. The description adds nothing beyond that: no statement about result volume, pagination, or whether an empty namespace yields all deployments across the region. With annotations doing the disclosure work, this is a bare-minimum pass.

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 front-loaded sentence with zero filler or repetition of the title. It is efficient, though the brevity reflects under-specification rather than disciplined editing.

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 say something about what a deployment record contains or how results are scoped, and it says nothing. For a tool in a large family of near-identical list operations, this leaves the agent guessing about scope and return shape.

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 (region, namespace) are documented in the schema and the baseline is 3. The description contributes no extra semantics — notably it does not clarify whether omitting namespace widens the query to the whole region, which is the one thing the schema leaves ambiguous.

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?

States a specific verb (List) and resource (CCI deployments) and expands the CCI acronym, so the agent knows exactly what entity is returned. It stops short of differentiating from the adjacent hcloud_list_cci_namespaces and hcloud_list_cci_pods siblings, which a stronger definition would contrast against.

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 versus the other CCI list tools, no mention that namespace is an optional narrowing filter, and no prerequisites (region appears required but the description never says a region scope is mandatory). Usage must be inferred entirely 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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is fully covered without the description. The description adds nothing beyond expanding the acronym - no note on whether all namespaces in the region are returned, pagination, or whether the region scopes the query.

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 short sentence with the resource front-loaded and zero filler. It is efficient, though the same brevity is what leaves the other dimensions thin.

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 one-parameter read-only list tool with annotations and no output schema, this is minimally sufficient to call correctly. It stops short of describing what a returned namespace looks like or how results are scoped, which an agent discovering CCI resources would benefit from.

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 'region' parameter, so the description does not need to restate it. However, the schema's own text is only 'Region', and the description does nothing to clarify region format or whether it narrows the namespace listing, leaving it at the baseline.

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 ('List') and resource ('CCI namespaces'), and expands the CCI acronym, so the agent knows exactly what is returned. It does not distinguish itself from siblings like hcloud_list_cci_deployments or hcloud_list_cci_pods, but the unique resource noun makes the scope unambiguous anyway.

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 when-to-use guidance, no prerequisites, and no reference to any alternative tool. The agent must infer from the name alone that this is the entry point for discovering namespaces before calling pod or deployment listings.

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, idempotentHint and openWorldHint, so the safety profile is covered structurally. The description adds nothing further — no note on whether listing is paginated, region-scoped, or whether namespace/deployment narrow the result set, so it contributes no behavioral context beyond the annotation set.

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 front-loaded sentence with zero filler and a useful acronym expansion. It is efficient, though the terseness leans toward under-specification rather than optimal 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 three-parameter, read-only list tool with full schema coverage and no output schema, the description is minimally adequate. It omits the filtering behavior of namespace/deployment_name and any note on result volume, which an agent would want before invoking 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 coverage is 100%, with all three parameters (region, namespace, deployment_name) documented, so the baseline is 3. The description adds no meaning about how these filters combine or whether namespace and deployment_name are optional scoping filters versus selectors.

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 gives a specific verb plus resource ('List CCI pods') and expands the CCI acronym, so the agent knows exactly what is returned. It is distinguishable from siblings like hcloud_list_cci_namespaces and hcloud_list_cci_deployments by the resource noun, though it never explicitly contrasts them.

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 call this versus hcloud_list_cci_deployments or hcloud_list_cci_namespaces, and no prerequisite or scope conditions are stated. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing beyond that  no note on pagination behavior, default result size, whether results are scoped by protection object, or what a caller can expect from an empty result.

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 short sentence, front-loaded with the verb and resource, with no wasted words. Its brevity is appropriate, though it borders on under-specification rather than tight editing.

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 list tool with no output schema, the description says nothing about returned fields, pagination semantics, or the relationship between region and object_id, which the terse schema labels leave ambiguous. An agent cannot determine from this definition alone how to scope the query correctly.

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

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

Schema description coverage is 100%, so all four parameters (region, object_id, limit, offset) are already documented, and the baseline of 3 applies. The description adds no extra meaning, such as whether object_id is required in practice to get meaningful ACL rules or how limit/offset interact.

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?

States a specific verb (List) and resource (CFW ACL rules) and expands the CFW acronym, so the operation is identifiable. However, it offers no differentiation from closely related siblings such as hcloud_list_cfw_firewalls and hcloud_list_cfw_service_rules; the reader must infer the distinction from the resource noun alone.

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 when-to-use guidance, no mention of prerequisites (e.g., that ACL rules are scoped to a firewall or protection object), and no pointer to alternatives. The agent must guess the context in which this list should be called instead of the sibling CFW list tools.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing beyond them — no mention of pagination behavior despite limit/offset params, no scope or filtering limits, no note on what is returned.

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 short sentence with zero wasted words and the resource front-loaded. It is efficient, though its brevity borders on under-specification rather than deliberate precision.

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

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

For a simple list tool the definition is thin: no output schema exists, so the description should at least hint at what is returned or that results are paginated, and it never states that region is mandatory scoping. The annotations cover safety but not result shape.

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 limit, offset and the required region are already documented in the schema. The description adds no meaning beyond it, which is the baseline-3 case 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?

States a verb and resource ('List CFW firewalls') and expands the CFW acronym, which is mildly useful. But it essentially restates the tool name and does not distinguish it from the closely related CFW siblings (hcloud_list_cfw_acl_rules, hcloud_list_cfw_service_rules) beyond the noun.

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 when-to-use guidance, no prerequisites, and no pointer to alternatives or related tools. The agent must infer from the name alone that this enumerates top-level firewall instances rather than ACL or service rules.

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, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds nothing beyond that: it does not mention pagination behavior, that region scoping is mandatory, or how results relate to object_id, which would be valuable context for a list 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 short phrase, front-loaded with the verb and resource, with no wasted wording. It is terse to the point of under-specification, but nothing in it is extraneous.

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 four parameters, a required region, and no output schema, the description should at minimum explain what a service rule contains and how pagination returns results. Instead it provides only the tool's name restated in prose, leaving the agent to rely wholly on structured fields.

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 four parameters (limit, offset, region, object_id) are already documented in the schema, establishing a baseline of 3. The description adds no additional meaning beyond the schema, such as what a protection object is or whether filters combine.

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 ("List") and a specific resource ("CFW (Cloud Firewall) service rules"), and expands the CFW acronym so the agent knows the domain. It implicitly distinguishes itself from siblings like hcloud_list_cfw_firewalls and hcloud_list_cfw_acl_rules by naming a different rule collection, though it never explicitly contrasts them.

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 hcloud_list_cfw_acl_rules or hcloud_list_cfw_firewalls, and no stated prerequisites or exclusions. The agent must infer usage entirely from the tool name.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered by structured data. The description adds no behavioral context of its own — nothing about pagination defaults, result caps, or what an empty project scope returns — so it contributes essentially nothing beyond the annotations.

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

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

A single short sentence with zero redundant wording, and the scope element is front-loaded. It is efficient, though its brevity borders on under-specification rather than true 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 listing tool with four parameters and no output schema, the description should at least indicate the required region and the pagination behavior. As written, an agent gets no help beyond the title, leaving role-defining details entirely to the schema 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 description coverage is 100%, so all four parameters (limit, offset, region, project_id) are documented in the schema and the baseline of 3 applies. The phrase 'in a project' loosely correlates with project_id but adds no format, default, or constraint information beyond what the schema already states.

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 names a specific verb ('List') and resource ('CodeArts pipelines') scoped to a project, which separates it from siblings like hcloud_list_codearts_projects and hcloud_list_codearts_repositories. It does not explicitly call out those siblings, but the resource noun is distinctive enough for disambiguation.

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 when-to-use guidance, no prerequisites (e.g. that region is mandatory), and no mention of when to prefer a different CodeArts listing tool. The only hint of usage is the phrase 'in a project', which implies a project scope but leaves the agent to infer 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: no note on whether results are scoped to the caller's account, whether region materially changes the result set, or what the listing contains.

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 single phrase is technically tight with no filler, and it is front-loaded. But the brevity here reflects under-specification rather than economy, leaving no room for the sibling differentiation a list tool in this crowded namespace needs.

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 parameterized list tool with no output schema, the description should at minimum say what a returned project represents and how paging behaves. With dozens of list_* siblings and no return-shape or scoping detail, an agent can call it but cannot confidently reason about what comes back.

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 limit, offset, and region all self-documented, so the baseline of 3 applies. The description contributes no extra meaning such as default page size, max limit, or accepted region formats.

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?

"List CodeArts projects" names a verb and a resource, so the basic purpose is legible. However, it does nothing to distinguish this from siblings like hcloud_list_codearts_repositories, hcloud_list_codearts_pipelines, or notably hcloud_list_projects (IAM projects), which an agent could easily confuse with CodeArts projects.

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 at all on when to use this versus the other CodeArts list tools or the generic project listing. The agent must infer the distinction from the tool name alone, and there are no exclusions or prerequisites stated.

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, idempotentHint and openWorldHint, so the safety profile is covered. The description adds only that results are scoped to a project; it says nothing about pagination defaults, total counts, or whether an empty project returns an empty list versus an error.

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 front-loaded sentence with no filler or redundancy. It is efficient, though its brevity crosses into under-specification rather than genuine tightness.

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

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

This is a simple read-only list tool with fully documented parameters and safety annotations, so the bar is low and the definition is minimally sufficient. It still leaves gaps around pagination behaviour and how project_id is obtained, which matter for a list-and-page 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 limit, offset, region and project_id are each documented in the schema. The phrase 'in a project' loosely ties project_id to the operation, but the description adds no filtering semantics or defaults beyond what is already structured.

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 ('List') and a specific resource ('CodeArts repositories'), scoped to a project. It implicitly separates itself from siblings like hcloud_list_codearts_projects and hcloud_list_swr_repositories by naming CodeArts repositories, but it never explicitly contrasts with them.

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 when-to-use guidance, no mention of prerequisites such as needing a project_id first, and no reference to alternatives (for example the SWR repository lister). The agent must infer everything about selection from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered structurally. The description adds essentially nothing beyond that: no pagination behavior, no result-size expectations, no indication of what a "catalog" contains or whether listing is scoped by project/region defaults.

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 short sentence with the resource and scope front-loaded and no filler. It is efficient, though the terseness shades into under-specification rather than genuine economy.

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 two-parameter read-only list tool with full schema coverage and no output schema, the description covers the bare minimum of what the tool returns conceptually. It still omits pagination, region requirements, and relationship to the sibling workspaces tool, which an agent would need for correct 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%, so both region and workspace_id are already documented in the schema. The description only echoes the workspace scoping idea and adds no format, default, or interaction details, 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?

"List DataArts catalogs in a workspace" names a specific verb (list) and resource (DataArts catalogs), so the operation is identifiable. However, it doesn't distinguish this from the sibling hcloud_list_dataarts_workspaces or explain how catalogs relate to workspaces, leaving the scope only partially defined.

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 when-to-use guidance, no mention of alternatives, and no exclusions. The one scoping hint ("in a workspace") is ambiguous because workspace_id is optional in the schema, so an agent can't tell whether workspace filtering is required or optional.

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, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that – no statement about pagination behavior, completeness of results, or what region scoping implies – so it contributes no behavioral 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 short phrase with no padding and is fully front-loaded. It is not verbose; its shortfall is under-specification rather than wasted wording.

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 list tool with three parameters, one required, and no output schema, the description should at least explain the region requirement and the pagination model. Neither appears, so an agent must rely entirely on the input schema 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 description coverage is 100%, with limit, offset, and the required region all documented in the schema, so the baseline of 3 applies. The description itself explains no parameter meaning whatsoever, leaving the schema to do all the work.

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

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

The description "List DataArts workspaces" simply restates the tool name hcloud_list_dataarts_workspaces and the verb/resource pair already encoded there. It does not distinguish the tool from the sibling hcloud_list_dataarts_catalogs or explain what a DataArts workspace is, so it adds almost nothing beyond the name.

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

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

There is no guidance about when to use this tool, when to prefer hcloud_list_dataarts_catalogs, or what prerequisites exist (such as region or project scoping). Usage must be inferred entirely 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds only the service scoping ('DCS (Redis)') and says nothing about whether results vary by region, caching, or failure behavior for an invalid region.

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 sentence, front-loaded with the verb and resource, with no redundant wording. It is efficient, though its brevity is partly under-specification rather than deliberate tightness.

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

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

For a single-parameter read-only list tool with no output schema, the description is minimally adequate. An agent still cannot tell what fields each zone entry contains or how this differs from the generic availability-zones tool, but nothing about invocation is actively wrong.

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%, but the sole parameter is documented only as 'Region', which conveys no format, enumeration, or example. The description mentions no parameter at all, so it fails to compensate for a schema that is technically complete but semantically thin. Baseline 3 applies given full 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 gives a specific verb and resource ('List available availability zones') scoped to the DCS/Redis service, which separates it from most siblings such as hcloud_list_dcs_flavors. It does not, however, distinguish itself from hcloud_list_availability_zones, the compute-level counterpart, leaving the agent to guess which AZ list applies.

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 explicit when-to-use guidance, no statement of prerequisites (a valid region must be chosen first), and no mention of the alternative hcloud_list_availability_zones. The agent must infer the usage scenario entirely from the tool name and the DCS parenthetical.

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, idempotentHint=true, and openWorldHint=true, so the safety profile is fully covered. The description adds essentially no behavior beyond that — it does not say results are scoped by the required region, whether the list is paginated, or roughly what a flavor entry contains; the only extra value is clarifying that DCS means Redis.

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 front-loaded sentence with zero filler and no restating of the title verbatim. It is efficient, though its brevity is closer to under-specification than to disciplined 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?

The tool is simple (one required param, read-only, no output schema) and the annotations carry the safety profile, so the definition is minimally callable. Still, for a discovery tool the agent would benefit from knowing that the region argument ties to hcloud_list_dcs_available_zones and what the returned specs cover — neither is stated.

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

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

There is a single required parameter with 100% schema description coverage, so the baseline is 3 by rule. However the schema text is just 'Region', and the description does not clarify the expected format (e.g., region code vs. name) or that valid values come from hcloud_list_dcs_available_zones, so nothing is added 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?

States a specific verb (list) and resource (DCS/Redis instance flavors/specs), and the 'DCS (Redis)' gloss disambiguates it from the many other flavor-listing siblings such as hcloud_list_rds_flavors, hcloud_list_gaussdb_flavors, and hcloud_list_dds_flavors. It does not explicitly distinguish itself from hcloud_list_dcs_instances or hcloud_list_dcs_available_zones, but the noun phrase 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 is only a purpose statement; it never says when to call this versus alternatives, nor that it is typically used to discover valid flavors before creating a DCS instance. There is no mention of the region prerequisite or of the related hcloud_list_dcs_available_zones sibling, leaving all usage inference to the agent.

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

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

The annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered without the description. The description adds only the DCS-equals-Redis clarification; it says nothing about filtering behavior, pagination, or what a listing contains.

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 single phrase is efficient and front-loaded with the verb, but its brevity stems from under-specification rather than disciplined editing. Nothing is wasted, but very little is delivered.

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-only list operation this is close to sufficient, especially since annotations cover the safety profile. With no output schema, however, the description should at least indicate what fields a returned instance carries or how limit behaves.

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 both parameters (limit and required region) are documented by the schema itself. The description adds no semantics beyond that, and the bare "Region" and "Max results" schema texts give no format examples, 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 gives a specific verb and resource ("List DCS instances") and usefully expands DCS as Redis, which an agent may not know. It does not, however, distinguish itself from siblings such as hcloud_show_dcs_instance or hcloud_list_dcs_flavors, so the agent must infer the difference from the names alone.

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 prefer this tool over hcloud_show_dcs_instance or hcloud_list_dcs_flavors, and no mention of how to page through results using limit. Usage is only implied by the verb "List".

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, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing beyond that: no pagination behavior, no filtering semantics, and no indication of what a returned 'flavor/spec' contains.

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 front-loaded sentence with zero filler; the parenthetical disambiguation 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 two-parameter read-only list tool with full schema coverage and no output schema, the minimum is met, but an agent gets no sense of result contents (CPU/memory/disk specs) or whether results are scoped to a region.

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 schema itself documents both parameters (engine, region required). The description mentions neither parameter and adds no meaning such as whether engine filters results or defaults to MongoDB, 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 gives a clear verb ('List') plus the specific resource ('DDS (MongoDB) instance flavors/specs') and even expands the DDS acronym, which distinguishes it from the many sibling flavor-listing tools (rds_flavors, dws_flavors, gaussdb_flavors, dcs_flavors, elb_flavors). It stops short of explicitly naming those siblings as alternatives, so it is clear but not fully differentiated by routing language.

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 explicit when-to-use guidance, no prerequisite notes (e.g., that it is typically called before creating a DDS instance), and no mention of which sibling flavor lister to pick for other engines. Usage is only implied by the resource 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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered elsewhere. The description adds nothing beyond that — no note on pagination, result ordering, whether the list can be empty, or how limit interacts with the returned set.

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 compact phrase with no filler and the key identifying information front-loaded. It is arguably too terse rather than wasteful, so it does not lose points for verbosity.

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

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

For a simple read-only list tool with a fully documented two-parameter schema and no output schema, the description is minimally sufficient to call it correctly. However, it omits what an agent gets back and whether the region filter is mandatory, which matters for planning a call.

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 only two flat parameters, so the schema already explains both fields. The description contributes no extra meaning about region scoping or limit behavior, leaving it at the baseline for fully-covered schemas.

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?

States a specific verb ("List") plus resource ("DDS instances") and disambiguates the acronym as MongoDB, which separates it from adjacent siblings like hcloud_list_dcs_instances or hcloud_list_rds_instances. It stops short of naming a sibling it is deliberately not, so not a 5.

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 versus alternatives, no mention of prerequisites such as a project/tenant context, and no indication of what to do with the results. The required region parameter implies scoping but the description never says so.

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, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing further — no indication of whether results vary by region or engine, whether the list is paginated, or what the entries represent — so it contributes no behavior beyond the structured fields.

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 short sentence with no filler and the resource front-loaded. Its brevity is efficient, though the same terseness leaves content gaps that belong to other dimensions.

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

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

For a simple read-only list tool with annotations covering safety and no output schema, this is minimally adequate. It still omits the relationship between the region/engine inputs and the returned storage types, and gives no guidance on how the result should be used.

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 ('engine', 'region') documented, so the baseline of 3 applies. The description mentions neither parameter, so it adds no meaning about how region or engine constrain the returned storage types.

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

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

States a specific verb (List) and resource (DDS/MongoDB storage types), and the parenthetical disambiguates DDS as MongoDB rather than another engine. It does not explicitly distinguish itself from hcloud_list_rds_storage_types or hcloud_list_dds_flavors, so the agent must infer the difference from the name alone.

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 when-to-use guidance: nothing says this is for choosing storage during DDS instance creation, nor when to prefer hcloud_list_dds_flavors or hcloud_list_rds_storage_types. The only cue is the tool name and a single implied 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 annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds only the zone-scoping behavior; it does not disclose pagination behavior, default result limits, or anything about the returned record set structure.

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

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

The description is a single front-loaded sentence with no filler or redundant wording. It is appropriately sized for an operation whose detailed parameter semantics are already handled by the schema.

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

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

For a simple read-only list tool with full schema coverage and annotations, the core purpose is conveyed. However, without an output schema, the description should ideally mention pagination or return-shape expectations rather than stopping at the scoping phrase.

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 are already documented in the schema. The phrase 'in a zone' reinforces the role of zone_id, but the description adds no further meaning for region or limit beyond what the schema 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 uses a specific verb and resource: 'List DNS record sets,' scoped 'in a zone.' It is clear what the tool does, though it does not distinguish itself from nearby DNS tools such as zone listing or zone detail retrieval.

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 only implied by the verb 'List' and the zone scoping. The description gives no explicit guidance on when to use this instead of hcloud_list_dns_zones or hcloud_show_dns_zone, nor does it mention that a zone ID must be obtained 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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered without the description. The description adds nothing further: it says nothing about result volume, pagination via the limit parameter, or what a zone listing contains. 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 only four words, so there is no waste or burying of key information. However, this brevity reflects under-specification rather than disciplined editing; there is no structure to speak of and no front-loaded detail beyond the bare 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?

For a listing tool with a required region parameter and optional type/limit filters, a four-word description is thin. There is no output schema, so the description could have explained what a zone entry includes or how pagination behaves, and it omits any routing to the show/recordsets siblings.

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

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

Schema description coverage is 100%, so all three parameters (type, limit, region) are already documented in the schema, which sets the baseline at 3. The description adds no meaning beyond the schema - it does not even indicate that region is required or that type filters public vs private zones.

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?

"List DNS zones" names a verb and resource but is essentially a restatement of the tool name hcloud_list_dns_zones. It gives no scope detail (region scoping, public vs private) and does not distinguish this from the closely related siblings hcloud_show_dns_zone and hcloud_list_dns_recordsets.

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 when-to-use or when-not-to-use guidance, and no mention of alternatives such as hcloud_show_dns_zone for a single zone or hcloud_list_dns_recordsets for records within a zone. The agent must infer the intended role from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety and idempotency profile is covered. The word "authenticated" hints at auth requirements, but the description adds nothing about scope, pagination, or what a domain object contains.

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 short phrase with no wasted words, and the resource is front-loaded. It is perhaps too terse to deserve a 5, but nothing is bloated.

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-parameter, read-only list tool with full annotation coverage, the description is minimally sufficient. However, with no output schema, the agent gets no sense of what fields a returned domain has, so it is adequate but thin.

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 takes zero parameters, so the baseline is 4. There is nothing the schema could document that the description omits; the description need only convey the resource, which it does.

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 and resource: "List authenticated IAM domains." It is distinguishable from IAM siblings like hcloud_list_users, hcloud_list_groups, and hcloud_list_agencies, though it does not explicitly name which sibling to use for related domain queries.

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 explicit when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer that this is the tool for enumerating IAM domains from the name alone.

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

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

The annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered elsewhere. The description adds essentially no behavioral context beyond the annotations: it says nothing about pagination behavior (limit/offset), result volume, or whether region scoping restricts the listing, which is the one subtlety an agent would benefit from knowing.

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 front-loaded sentence with no wasted wording. It is efficiently written, though its brevity reflects under-specification rather than disciplined editing.

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 full schema coverage and annotations carrying the read-only/idempotent profile, and no output schema to explain, the description is adequate for a basic listing call. However, for a tool whose only required parameter is a region scope and which paginates, the absence of any note on pagination or result set size leaves a modest 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%, so every parameter including the job_type enum is documented in the schema itself. The description only gestures at "optional filters" without adding syntax, combinability, or default semantics 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 states a specific verb and resource ("List DRS jobs") and usefully expands the DRS acronym, which is not obvious from the name alone. It does not explicitly distinguish itself from the closely related siblings hcloud_show_drs_job and hcloud_list_drs_quotas, so it stops short of a 5.

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 "with optional filters" hints that all filters can be omitted and only region is mandatory, but there is no explicit when-to-use guidance, no mention of when to prefer hcloud_show_drs_job for a single job, and no stated prerequisites or scope constraints.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the description's only remaining job would be to add behavioral context — but it adds none. It does not say whether the response is per-region, whether results are paginated, or whether quotas can be zero/absent for a region. It also does not contradict the annotations.

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

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

One short sentence with zero padding, and the verb and resource are front-loaded. Its brevity is also its weakness — nothing is wasted, but nothing extra is spent on orientation either.

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

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

For a single-parameter, read-only list tool with full annotation coverage and no output schema, this is close to the minimum acceptable. Still, it never states what a 'quota' record contains or what a caller should do with it, and the 'tenant' framing sits uneasily with a required region argument.

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 a single required 'region' parameter, so the schema does the documenting and a baseline of 3 applies. The description adds no meaning beyond the schema; in fact the phrase 'for the tenant' is the only scoping information and it does not explain how 'region' narrows that scope.

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 pairs a specific verb ('List') with a specific resource ('DRS quotas') and a scope ('for the tenant'), so an agent can tell it apart from lifecycle siblings like hcloud_list_drs_jobs and hcloud_show_drs_job. It falls short of 5 because it does not distinguish itself from the other quota-reading tools in the fleet (hcloud_show_quota, hcloud_list_eip_quotas), whose scope overlaps conceptually.

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 call this tool versus alternatives, no prerequisites, and no note on what it is useful for (e.g. capacity planning before creating DRS jobs). The reader must infer the purpose from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered without prose. The description contributes only the acronym expansion and resource scope; it says nothing about whether results are paginated by limit/offset, whether region is mandatory, or how large the listing can get.

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 front-loaded sentence with zero filler or redundancy. It is well structured but so terse that the brevity comes at the cost of guidance, which is why it is not a 5.

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 three-parameter list tool with no output schema and no nesting, this is minimally adequate: the agent knows what it lists and the schema supplies the parameters. Missing are any note about pagination behavior or what a cluster record contains, which an agent planning a call would find useful.

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 region, limit and offset are already documented in the schema, and the description adds no syntax, format, or defaulting detail beyond that. Baseline 3 applies when the input schema carries the parameter 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 pairs a specific verb (List) with a specific resource (DWS clusters) and expands the DWS acronym as GaussDB Data Warehouse, which distinguishes it from the nearby hcloud_list_gaussdb_instances and hcloud_list_mrs_clusters. It stops short of naming those siblings or the corresponding hcloud_show_dws_cluster, so differentiation is implied rather than stated.

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 when-to-use guidance at all: nothing says to call this before hcloud_show_dws_cluster for details, or why one would pick the DWS cluster list over hcloud_list_dws_flavors. The agent must infer the choice purely from the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds essentially no behavioral context beyond the annotations: it does not say whether results are region-scoped (the sole parameter implies it but never states it), whether the list is paginated, or whether flavors differ by availability zone. For a one-param read tool this is tolerable, but the text contributes little.

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 front-loads the verb and resource, expands the DWS acronym inline, and contains no filler. Nothing could be removed without losing 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?

With no output schema, the description is the only place an agent could learn what a flavor record contains, and it stops at 'flavors/specs'. For a simple list tool with one fully-documented parameter this is adequate, but it leaves the agent guessing about the return shape and any region coupling.

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

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

Schema description coverage is 100% for the single required parameter, so the schema already carries the documentation burden; the description neither names 'region' nor explains its accepted format (region ID vs. name) or whether it must match the target cluster's region. Baseline 3 applies when the schema does the work.

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?

States a specific verb (List) and a well-scoped resource (DWS GaussDB Data Warehouse cluster flavors/specs), and the DWS qualifier distinguishes it from sibling flavor lists such as hcloud_list_dcs_flavors, hcloud_list_gaussdb_flavors and hcloud_list_rds_flavors. It does not explicitly route to those siblings, but the resource naming 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?

There is no when-to-use guidance, no mention of a prerequisite step (e.g., call this before creating or resizing a DWS cluster), and no exclusion or alternative named. An agent can infer it is a lookup, but nothing in the text says why or when to pick it over hcloud_list_dws_clusters or hcloud_show_dws_cluster.

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, idempotentHint=true and openWorldHint=true, so the safety profile is supplied structurally. The description adds nothing beyond them: no note that results are region-scoped, no indication of quota dimensions (used vs total), and no behavior for an unknown region. With annotations covering safety, the description still fails to contribute any extra operational context.

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

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

A four-word phrase, front-loaded with the verb and resource and free of filler. Its brevity is efficient but edges toward under-specification rather than genuine 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 one-parameter, read-only list tool with no output schema, a short description is defensible, but it omits the region scoping and the nature of the quota data returned. It is minimally sufficient rather than complete.

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

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

Schema description coverage is 100% but the single parameter is documented only as "Region" with no format hint. Per the high-coverage baseline this lands at 3, and the description does not compensate by naming expected region-code syntax or regional scoping behavior.

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

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

"List EIP resource quotas" names a specific verb (list) and resource (EIP quotas), which separates it from siblings such as hcloud_show_quota and hcloud_list_drs_quotas that deal with different quota scopes. It does not, however, spell out what an EIP quota represents or what the returned items look like.

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 hcloud_show_quota or other quota-listing tools, and no stated prerequisites beyond the required region. The agent must infer usage entirely 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?

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description adds nothing further - no note that region is mandatory, whether results are paginated, or whether flavor availability varies by region, which is the one behavioral point an agent would actually need 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?

A single five-word phrase that front-loads the verb and resource with zero filler. Nothing could be removed without losing 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 one-parameter read-only listing tool this is minimally adequate, and the absence of an output schema means return values need not be explained. However, an agent would benefit from knowing what a 'flavor specification' contains (vCPU, memory, bandwidth) and whether the region scope limits results.

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%, but the schema's only annotation for the region parameter is the bare word 'Region'. The description does not compensate by clarifying expected format or scoping behavior. With full 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?

placeholder

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 versus hcloud_list_flavors or other flavor-listing siblings, nor any prerequisite such as the need to pick a flavor before creating a load balancer. Usage is only implied by the tool name.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so safety is covered. The description adds no behavior beyond that — nothing about pagination semantics (limit/offset defaults or maximums), result ordering, or what happens with an invalid router_id in an open-world API.

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 front-loaded sentence with no wasted words. However, the terseness borders on under-specification rather than true economy, since essentials like pagination behavior are omitted entirely.

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

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

For a simple read-only list tool with full schema coverage, no output schema and rich annotations, the description is only just adequate. It leaves an agent to guess at paging behavior and the shape of returned attachments, which matters for a list endpoint.

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 schema already documents all four parameters, meeting the baseline. The description contributes no extra meaning (e.g., valid region values or whether offset requires limit), so it neither helps nor hurts.

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?

States a specific verb ('List') and resource ('attachments') scoped to an ER (Enterprise Router) router, which is unambiguous. It does not differentiate from nearby siblings such as hcloud_list_er_routers or hcloud_list_er_route_tables, so an agent must infer the boundary from the name alone.

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?

'for a specific ER router' implies the precondition that a router_id must already be known, but there is no explicit when-to-use guidance, no exclusion of alternatives, and no note on how this relates to listing routers or route tables 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, openWorldHint, and idempotentHint, so the safe read-only nature is covered elsewhere. The description adds no behavioral context beyond restating that this lists routers; it does not mention pagination, result ordering, or regional scoping 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 front-loaded sentence with no redundant wording, which suits a simple list operation. It is terse but not unclear, and nothing in it is wasted.

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

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

For a simple read-only list tool with full schema coverage and strong annotations, the definition is minimally sufficient. However, it lacks any mention of regional scope or pagination behavior, and there is no output schema to explain the returned router list.

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%, covering region, limit, and offset, so the schema already carries parameter meaning. The description adds no parameter-specific detail such as whether region is mandatory or how pagination should be used; 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 gives a clear verb and resource: "List ER (Enterprise Router) routers", and it expands the ER acronym so the agent knows the object type. It is distinguishable from the sibling hcloud_show_er_router by being a list operation, but it does not further differentiate from hcloud_list_er_route_tables or hcloud_list_er_attachments.

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

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

The description states only that this is a listing operation. It gives no explicit when-to-use guidance, no prerequisites, and no alternatives such as hcloud_show_er_router for a single router or the route-table/attachment list tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered by structured data. The description adds the useful constraint that results are scoped to one router, but says nothing about pagination behavior or result shape beyond what the limit/offset params imply.

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 front-loaded sentence with no filler, giving the action and the scope immediately. It is efficient, though it leaves no room for the routing guidance a one-line description would have benefited from.

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 paginated list tool with full schema coverage and read-only annotations, most of what an agent needs is present, and the absence of an output schema is not disqualifying. The only real gap is disambiguation from the generic hcloud_list_route_tables sibling.

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 four parameters (limit, offset, region, router_id) are already documented, and the baseline is 3. The description reinforces that router_id targets an Enterprise Router but adds no format, syntax, or default-value detail 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 supplies a specific verb and resource ('List route tables') and scopes it to a particular ER (Enterprise Router) router, expanding the ER abbreviation so the agent knows the domain. It falls short of a 5 because it never distinguishes this from the sibling hcloud_list_route_tables, which an agent could easily confuse it with.

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 only implied: the phrase 'for a specific ER router' signals that router_id and region are prerequisites, which matches the required fields. There is no explicit when-to-use statement, no statement of when not to use it, and no pointer to hcloud_list_route_tables for the non-ER 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?

Annotations already declare readOnlyHint, openWorldHint and idempotentHint, so the safety profile is covered externally. The description adds nothing beyond the name: no indication of whether results are region-scoped, whether deprecated or unavailable flavors are included, or how large the result set typically is.

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 short sentence with zero filler, which is structurally clean. However, brevity here crosses into under-specification rather than efficient communication, leaving no front-loaded operational 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-only list tool with a fully described two-parameter schema and no output schema, the minimum an agent needs is present via annotations and schema. Still, given the crowded family of flavor-listing siblings, a sentence on scope and return content would materially help correct 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%, so both parameters (region, availability_zone) are documented in the schema and the baseline of 3 applies. The description does not clarify the region semantics (which region's catalog is queried) or the filtering behavior of availability_zone, so it adds no 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 gives a specific verb plus resource ("List available ECS instance flavors/specs"), which is enough to know it returns instance type catalog data. It is less explicit about which of the many sibling flavor tools (dcs, mrs, dws, gaussdb, elb, rds, dds) it contrasts with, relying on the tool name's prefix for 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 on when to use this versus the other *_list_*_flavors siblings or versus hcloud_list_servers. There is no mention of prerequisites, such as needing a region or that a region is required.

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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that — it does not say the listing is scoped by the required region, whether results are paginated or truncated, or what an entry represents.

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, front-loaded with the verb and resource, with no filler. It is efficient but borders on under-specification given the crowded gaussdb sibling set.

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 tool with full annotation coverage and no output schema, the essentials are present. However, nothing tells the agent how this differs from hcloud_list_gaussdb_flavors or hcloud_list_rds_datastores, which is the main ambiguity an agent would face.

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

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

There is a single parameter with 100% schema description coverage, so the schema already carries the parameter documentation and the baseline of 3 applies. The description does not add meaning about how region affects the returned versions, though little is needed for one 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 states a specific verb and resource ('List available GaussDB (openGauss) DB engine versions'), and the parenthetical clarifies the engine family. It does not distinguish this from the closely named sibling hcloud_list_gaussdb_flavors or from hcloud_list_rds_datastores, so an agent must infer the difference between engine versions, flavors, and RDS datastores.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. The agent is left to infer that this is a pre-creation lookup for engine versions rather than a flavor or instance listing, which is exactly where the sibling tools overlap.

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, idempotentHint=true and openWorldHint=true, so the safety profile is fully covered structurally. The description adds nothing on top of that – no note on whether the result set is region-scoped, whether unauthenticated/endpoint constraints apply, or how pagination/volume behaves for a catalog that can be long.

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, front-loaded sentence with no filler or redundancy. It is efficient but borders on under-specification, so it doesn't reach the top of the scale.

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

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

The tool is simple (two params, read-only, one required) and the annotations carry the safety semantics, so the definition is workable. Still, with no output schema and no explanation of what a flavor record contains or how filters interact, an agent has to guess at result shape and filtering behavior.

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

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

Schema description coverage is 100%, so both parameters (region, db_type) are already documented in the schema, and the baseline of 3 applies. The description mentions 'flavors/specs' but doesn't clarify how db_type filters or whether region restricts the returned catalog beyond what the schema states.

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 pair ('List... GaussDB (openGauss) instance flavors/specs') that maps directly onto the tool name and separates it from the many sibling flavor-listers (hcloud_list_dcs_flavors, hcloud_list_rds_flavors, hcloud_list_dws_flavors) via the named service. It doesn't, however, say how it relates to those siblings or what a 'flavor' entails in this 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?

There is no when-to-use or when-not-to-use guidance and no mention of alternatives or prerequisites. The agent can infer that this is a discovery call made before provisioning a GaussDB instance, but nothing in the text confirms that or excludes other calls.

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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: no statement about pagination behavior, default limits, cross-region scope, or what a listing actually contains, which is the remaining value it could have supplied.

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 short fragment with zero wasted words, and the resource is front-loaded. It is efficient but so terse that it has no room for structure (no conditions, no scope qualifiers), which keeps it just short of a top mark.

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

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

The tool is simple (one required param, all params documented, no output schema), so the minimal description is not disastrous. Still, it omits what a caller would want for a list operation — pagination defaults, region scoping, and the fact that filtering is available via db_type — leaving real gaps for an otherwise straightforward 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 description coverage is 100%, so all four parameters (region, limit, offset, db_type) are documented in the schema, making a baseline of 3 appropriate. The description contributes no additional semantics such as valid db_type values, default page size, or whether region is mandatory for scoping.

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 (List) and resource (GaussDB/openGauss instances), and the parenthetical clarifies the engine, so an agent knows exactly what collection is enumerated. It does not, however, differentiate from adjacent siblings such as hcloud_list_gaussdb_flavors, hcloud_list_gaussdb_datastores, or hcloud_show_gaussdb_instance, so sibling disambiguation is left entirely to the tool name.

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

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

There is no when-to-use guidance, no mention of prerequisites such as a required region or credentials, and no pointer to alternatives (e.g. use hcloud_show_gaussdb_instance for a single instance's details). The agent must infer routing from the name alone.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds nothing beyond the annotations — no pagination behavior, no indication of what 'limit' defaults to or caps at, and no note that results may span domains. With annotations carrying the burden this is a modest gap, but zero added context is a 2.

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?

Four words, front-loaded with verb and resource, with zero wasted phrasing. It is concise but borders on under-specified rather than richly structured.

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

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

For a simple one-parameter list operation with annotations covering safety and a fully described schema, the description is minimally adequate. It omits pagination semantics and scope context (domain/project) that an agent would want, but there is no output schema or nested structure demanding more.

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 single 'limit' parameter is already documented as 'Max results'. The description adds no meaning beyond the schema, so the baseline 3 applies rather than a higher score.

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?

States a specific verb ('List') and a specific resource ('IAM user groups'), which distinguishes it from neighbors like hcloud_list_users, hcloud_list_user_policies, and hcloud_list_lts_groups. It does not explicitly contrast with any sibling, but the resource noun is narrow enough to be 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?

There is no when-to-use guidance, no prerequisites (e.g., IAM permissions or domain/region scope), and no mention of alternatives when a single group's details are wanted. Usage is only inferable from the verb itself.

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, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds nothing beyond that — no note on pagination behavior for 'limit', no indication of scope (all monitors in a region vs. per-pool), and no hint about what is returned.

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 four-word sentence with no filler, so nothing is wasted. However, the brevity is under-specification rather than efficient packing — there is room to add routing and scoping detail without bloat.

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 list tool with no output schema, the description should say at least what a health monitor record represents and how it relates to load balancers and pools. As written, an agent cannot tell the result shape or the relationship to sibling ELB list tools.

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 'region' and 'limit' documented, so the baseline of 3 applies. The description contributes no additional meaning about whether region is mandatory scoping or how limit interacts with pagination.

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?

States a specific verb (List) and a specific resource (ELB health monitors), which distinguishes it from generic load-balancer siblings like hcloud_list_load_balancers or hcloud_list_pools. It stops short of clarifying the parent object (listener/pool) health monitors hang off of, which is where the real ambiguity lies.

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 versus hcloud_list_pools, hcloud_list_members, or hcloud_show_load_balancer_topology, and no prerequisites such as needing a load balancer or pool ID. The agent must infer the usage context entirely.

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, idempotentHint and openWorldHint, so the safety profile is covered. The description adds only the downstream-consumption context and says nothing about pagination behavior, default result size, or whether the list is region-scoped beyond the required parameter.

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 front-loaded sentence with the resource first and the motivating use case second. No filler or redundant restatement of the tool name.

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 seven-parameter list tool with no output schema, the description does not indicate what fields come back (image IDs, names, status) or how results are ordered/limited, which matters since the stated goal is extracting an image_ref. Adequate but leaves a real gap for the caller.

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 seven parameters (including the filter enums for status, os_type, imagetype, architecture) are already documented in the schema. The description adds no filtering semantics or format hints beyond that, 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?

States a specific verb and resource ('List available IMS images') and adds the downstream purpose (finding image_ref for ECS/CCE/AS). It is clearly distinguishable from the sibling hcloud_show_image by the list-vs-show verb, though it never names that sibling explicitly.

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

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

The parenthetical gives a concrete use case (locating image_ref before creating ECS/CCE/AS resources), which implies when to call it. However, there is no explicit guidance on when to prefer hcloud_show_image or hcloud_list_os_versions instead, so the agent must infer the boundary.

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, idempotentHint=true, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond them – no note on pagination, whether all key pairs are returned regardless of region scoping, or result ordering.

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 words with zero padding, so nothing is wasted. However, brevity crosses into under-specification for a cloud API tool, leaving no room for the context a caller would want; it is efficient but thin.

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

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

The tool is simple – one required string parameter, no output schema, and annotations covering its read-only nature – so the minimal description is not crippling. Still, the meaning of 'region' and the scope of results are left unstated, which is a real gap for an open-world listing call.

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%, but the sole parameter's schema description is just "Region", which is nearly as terse as the tool description. The description does not compensate by explaining whether region filters results or is only a routing/endpoint selector. Per the high-coverage baseline, 3 is the appropriate ceiling here.

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?

"List SSH key pairs" gives a specific verb (list) and a specific resource (SSH key pairs), so the agent knows exactly what the tool returns. Differentiation from siblings is unnecessary here since no other sibling deals with key pairs, though the description itself does no explicit routing.

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, no prerequisites, and no exclusions. The only implied usage is the generic 'list a collection', which the agent must infer from the verb alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds value by naming the returned fields (state, creation date, etc.), which matters given there is no output schema, but it says nothing about behavior on a nonexistent key, cross-region lookup semantics, or permissions required.

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 short sentence with the resource and payload type front-loaded, no filler. The trailing 'etc.' slightly weakens precision but costs little space.

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

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

For a simple two-parameter read tool with annotations, this is close to adequate, and the parenthetical field list partly compensates for the missing output schema. It falls short on region/key_id semantics and failure behavior, which are the main things an agent could get wrong here.

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 only two required parameters, so the baseline is 3. The description adds no meaning beyond the schema — it does not explain that region selects the endpoint and must match the key's region, nor the key_id format.

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?

Names a specific verb and resource: 'Get details of a specific KMS key', which resolves the ambiguity of the misleading tool name (hcloud_list_kms_key_detail sounds like a list). It does not explicitly distinguish itself from the sibling hcloud_list_kms_keys, leaving the agent to infer that this is the single-key variant.

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 only implied by the phrase 'a specific KMS key' — the agent can infer this is for retrieving one key once its ID is known. There is no explicit when-to-use guidance, no statement of when to prefer hcloud_list_kms_keys instead, and no prerequisite or error-condition notes.

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, openWorldHint, and idempotentHint, so the safety profile is covered. The description adds nothing beyond that — no note on pagination behavior, whether results are region-scoped, or what happens when limit is omitted.

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 single phrase is free of waste and front-loaded, but it is so terse that it omits orientation an agent would want for a paginated, region-required list call.

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 list tool this is borderline adequate, but it never mentions that region is required nor how limit affects results. With no output schema, the description could have said more about the shape of the returned key set.

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 (region, limit) are already documented. The description adds no meaning about region scoping or limit semantics, which is acceptable given the schema carries the load, but is baseline at best.

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 gives a clear verb and resource ("List KMS encryption keys"), so an agent knows exactly what it retrieves. It does not explicitly distinguish itself from the sibling hcloud_list_kms_key_detail, though the naming implies the difference.

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 versus hcloud_list_kms_key_detail, nor any prerequisite or context statement. The agent must infer usage entirely from the name and schema.

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

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

The annotations already establish a read-only, idempotent, open-world operation, while the description adds the ELB URL-routing scope. It does not disclose pagination or truncation behavior, or whether omitting listener_id returns all policies in the region.

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 phrase with no redundant wording. It communicates the operation and resource efficiently without unnecessary implementation 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 three-parameter read-only list tool, the description and fully documented schema are sufficient for a basic invocation. Nevertheless, the absence of result-scope and pagination context, combined with no output schema, leaves some uncertainty about broader or truncated responses.

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 limit, region, and listener_id each documented, so the baseline score applies. The description adds no further parameter formats, defaults, or explanation of how the filters interact.

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 clear verb and resource: "List ELB URL-based routing policies." Expanding L7 into ELB URL-based routing makes the resource understandable, but it does not explicitly distinguish the tool from related listener, load-balancer, or other policy-listing siblings.

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 for agents that need to inspect ELB URL-routing policies, and the schema suggests optional listener-specific filtering. However, the description gives no explicit when-to-use guidance, prerequisites, or alternatives for related ELB resources.

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, idempotentHint and openWorldHint, so the safety profile is covered structurally. The description adds nothing beyond that: it does not mention pagination behavior for 'limit', whether listeners from all load balancers are returned when loadbalancer_id is omitted, or the shape of the result.

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?

It is a single front-loaded phrase with zero wasted words, but that brevity is closer to under-specification than to disciplined concision. Nothing is redundant because nothing is present.

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 three-parameter listing tool with a required region and no output schema, the agent still needs to know whether listeners can be listed across all load balancers, how 'limit' behaves by default, and what fields come back. None of that is covered, so the definition is thin relative to the tool's complexity.

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

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

Schema description coverage is 100%, so every parameter (limit, region, loadbalancer_id) is already documented in the schema, which sets the baseline at 3. The description does not clarify the interaction between region and loadbalancer_id or explain default page size, so it adds no 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 phrase 'List ELB listeners' names a verb and a resource, and the 'ELB' qualifier distinguishes it from generic listener listings. However, it is essentially the tool name restated with an acronym expanded, and it offers no differentiation from nearby siblings such as hcloud_list_load_balancers, hcloud_list_pools, or hcloud_list_l7_policies.

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, when to prefer hcloud_list_load_balancers or hcloud_show_load_balancer, or whether a load balancer must already be selected. The agent must infer all routing decisions from the name alone.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: no mention of result scoping by region, pagination/limit behavior, or what happens when the region has no load balancers. For a read tool the bar is lower, but zero added context earns a 2.

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 four-word phrase contains no filler and is inherently front-loaded, so there is nothing to trim. But its brevity comes from omission rather than efficiency — the sentence is too thin to convey scope or behavior, which places it below a well-sized one-liner.

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?

There is no output schema and no return-value description, and the required region scoping plus limit-based pagination go unmentioned, so an agent cannot tell how results are bounded or what a result item looks like. For a list tool with a required parameter and no output schema, more explanation is warranted.

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 'region' (required) and 'limit' documented in the schema, so the description does not need to restate them. However, it adds no meaning beyond the schema — e.g. whether the list is scoped to the required region or whether 'limit' truncates silently. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description pairs a specific verb (List) with a specific resource (ELB load balancers), so an agent immediately knows this is a collection-enumeration call for elastic load balancers. It does not differentiate from close siblings such as hcloud_show_load_balancer or hcloud_list_listeners, but the core 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?

There is no when-to-use guidance at all — nothing says to call this before hcloud_show_load_balancer to discover IDs, nor any prerequisite about having a region/project context. The only usage signal an agent gets is the tool name itself, which is not misleading but also not helpful.

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, idempotentHint and openWorldHint, so the safety profile is covered by structured data. The description adds only the acronym expansion and says nothing about pagination behavior, result caps, or the fact that the call is region-scoped. With annotations carrying the behavioral load, this is adequate but thin.

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 front-loaded sentence with no filler; the parenthetical acronym expansion is the one addition and it earns its place. It is efficient, though bordering on under-specified rather than maximally informative.

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

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

For a simple read-only list tool with full schema coverage and no output schema, the definition is just barely sufficient. The missing pieces are how this collection relates to LTS streams and what the region parameter means for reachability, which an agent would need to chain calls correctly.

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

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

Schema description coverage is 100%, with limit, offset and region all documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond the schema — not even which region values are valid or how limit/offset interact.

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?

States a specific verb ('List') and resource ('LTS log groups') and expands the LTS acronym, so the agent knows exactly what entity is returned. It does not explicitly distinguish this from the sibling hcloud_list_lts_streams, leaving the groups-vs-streams boundary implicit.

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 when-to-use guidance, no mention of when to prefer streams or another sibling, and no statement of prerequisites. The only hint that a region is mandatory comes from the schema's required list, not the description.

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, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds no behavioral context beyond that—nothing on pagination behavior, default limits, whether omitting log_group_id lists all streams, or result ordering.

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 front-loaded sentence with no filler. It is efficient, though the extreme brevity leaves no room for the routing or scoping details an agent would benefit from.