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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds no behavioral context beyond the bare retrieval action, such as what happens if the image is missing or how project scope is resolved.

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 sentence is front-loaded and contains no wasted words. It is perhaps too terse for a tool definition, but it is efficiently 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?

An output schema exists, so return values need not be explained. Annotations cover the safety profile. However, the description leaves gaps around project scoping, missing-image behavior, and differentiation from list_images, which are relevant for this retrieval tool.

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

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

Schema coverage is 50%, with project_id documented in the schema and image_id left to its self-explanatory name. The description adds slight value by stating the image is retrieved 'by ID', but does not explain the optional project_id or its default-project behavior.

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

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

The description states a specific verb and resource: retrieve one image by ID. This clearly distinguishes it from list_images, though it does not explicitly name the sibling tool or articulate scope differences.

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

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

The description gives no when-to-use guidance, no exclusions, and no alternative routing. It implies that an image ID is the key, but does not say when to use get_image versus list_images or how project scope affects the call.

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, openWorldHint and destructiveHint=false, so the safety profile is covered, but the description adds nothing beyond that: no note on behavior when the ID doesn't exist (error vs null), no cross-project visibility notes, no auth requirements. For a single-fetch tool this is a thin addition.

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, front-loaded sentence with zero padding. It is arguably too terse rather than bloated, but it does not waste any words.

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

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

An output schema exists, so return values need no explanation, and annotations cover safety. Still, for a lookup tool the description omits where network_id comes from and what happens on a miss, leaving it only minimally complete.

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

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

Schema coverage is 50%: project_id is documented in the schema (including a pointer to get_scope), but network_id has no description at all, only a min/max length. The description says 'by ID' but never clarifies ID format/source or how project_id scoping affects the lookup, so it fails to compensate for the undocumented 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?

States a specific verb and resource ('Get one network') plus the lookup key (by ID), which cleanly separates it from the sibling list_networks. It doesn't explicitly name the alternatives, but the singular-vs-list distinction is unmistakable from the name and sentence.

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

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

The description gives no guidance on when to use this versus list_networks or other get_* tools, and no prerequisites (e.g. requiring a known network_id obtained elsewhere). Usage is only inferable 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, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that allowed address pairs are included, but it omits behavior such as not-found handling or project scoping.

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. Every clause contributes either the operation or the notable returned content.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. Still, the description leaves gaps around project scoping and the required port_id parameter's semantics for a simple retrieval 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 50%: project_id is documented in the schema, but port_id has no schema description. The description only says 'by ID' and does not compensate with format, source, or constraint details for the required port_id 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: 'Get one port by ID.' It implicitly distinguishes itself from the sibling list_ports by fetching a single port, though it does not name 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 phrase 'Get one port by ID' implies usage for retrieving a single known port, which is adequate minimum guidance. However, it does not explicitly say when to use this instead of list_ports or what prerequisites exist.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds nothing beyond that — no error behavior for a missing router, no project-scoping implications, no note on what a router object contains. It merely restates the read operation the annotations already declare.

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. Its terseness is a completeness problem rather than a conciseness problem, so it scores well here.

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?

An output schema exists, so return-value explanation is not required, and the annotations cover the safety profile. However, for a tool sitting among 30+ OpenStack-style siblings, the description does not mention scoping (project_id / get_scope) or failure modes, leaving it only minimally complete.

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

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

Schema coverage is 50%: project_id is documented ('omit for the default project', pointing at get_scope), while router_id has no schema description. The phrase 'by ID' at least signals that router_id is the router identifier, partially compensating. Baseline 3 is appropriate for a two-parameter getter where the schema carries most of the burden.

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

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

States a specific verb+resource ('Get one router') and the retrieval key ('by ID'), which is enough to distinguish it from list_routers in the sibling set. It does not explicitly name the list/get pairing, but the singular-resource phrasing makes the distinction inferable.

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 instead of list_routers or list_router_interfaces, no prerequisite notes, and no mention of what happens if the ID is unknown. 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 readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely new behavioral context with "Does not contact the cloud," telling the agent this is a cheap local call that cannot fail on auth or network — useful information annotations do not convey.

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

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

Two sentences, no filler, and the payload statement comes before the operational caveat and the call-ordering advice. Every clause carries information an agent 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?

With an output schema present, return values need not be explained, and the description correctly stops short of that. The only soft spot is that bare terms like "mode" and "limits" are left for the output schema to define, but for a zero-parameter diagnostic tool this is essentially complete.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The prose correctly focuses on what the call returns rather than inventing input 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?

Uses a concrete verb ("Show") and enumerates the exact scope attributes returned: mode, allowed projects, limits, and credential status. This clearly separates it from the resource-oriented siblings (list_subnets, get_server, etc.), though it never explicitly names itself as the server-level diagnostic counterpart to 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?

"Call it first" is an explicit, actionable ordering instruction that tells the agent when to reach for this tool relative to everything else. No exclusion cases are stated, but none are plausible here since no sibling overlaps in function.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description usefully adds that rules are returned with the group, but says nothing about permission requirements, error behavior for missing IDs, or cross-project access.

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. Its brevity is appropriate, though it leaves little room for the guidance that is missing 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?

An output schema exists, so return-value detail is not required, and mentioning that rules are included is a helpful hint. Still, for a lookup tool with an undocumented required ID parameter, a note on ID source (e.g., from list_security_groups) would round it out.

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 only 50%: project_id is documented in the schema while security_group_id is not. The description's 'by ID' merely restates the parameter name and adds no format, constraint, or lookup semantics to compensate for the uncovered 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?

States a specific verb and resource ('Get one security group by ID') and notes that rules are included in the response, which distinguishes it from a bare metadata read. It does not explicitly contrast with the sibling list_security_groups, though 'one ... by ID' implies the distinction.

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

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

Usage is only implied: 'by ID' signals the lookup path versus listing, but there is no explicit statement of when to prefer this over list_security_groups or what happens if the ID is unknown. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered structurally. The description adds nothing beyond that — no note on not-found behavior, project scoping, or visibility constraints — so it earns little credit on top of 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 front-loaded sentence with zero filler, which is an appropriate shape for a simple getter. It is terse rather than padded, though the brevity costs it in 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. However, the description leaves the project_id scoping behavior and the ID's provenance unexplained, which is a real gap for a lookup tool in a multi-project API.

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 only 50%: project_id has a description pointing at get_scope, while server_id has none. The phrase "by ID" weakly confirms server_id is the identifier but gives no format, source, or scoping detail, and says nothing about the optional project_id 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 ("Get one server") and the retrieval key ("by ID"), which cleanly separates it from list_servers and other siblings. It stops short of naming an alternative, but the singular-vs-list distinction is unambiguous from the name and text.

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 list_servers, nor any precondition such as needing a server ID obtained from a prior list call. The agent must infer the workflow 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, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond that — no note on error behavior for a missing ID, cross-project lookup behavior, or visibility semantics.

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

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

A single short sentence with no wasted words and the key qualifier ("by ID") front-loaded. It is efficient, though it 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?

An output schema exists, so return values need not be described. However, for a tool with an optional project_id that changes scope, the description says nothing about cross-project behavior or where to obtain a valid subnet_id.

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 50%: project_id is documented in the schema, but subnet_id has no description. The phrase "by ID" confirms subnet_id is the sole lookup key, adding a small amount of meaning, but it does not compensate for the undocumented required 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?

"Get one subnet by ID" states a verb and resource, but it essentially restates the tool name and title. It implicitly contrasts with list_subnets (single vs. list) but never names the sibling or clarifies the scope.

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

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

There is no guidance on when to use this versus list_subnets or get_network, and no mention of prerequisites such as needing a subnet ID from a list call first. The agent must infer all 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, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond that — no word on behavior for missing IDs, errors, or project scoping — so it earns no extra credit.

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 efficiently sized, though arguably under-specified rather than optimally concise.

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

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

An output schema exists so return values need not be explained, and annotations cover safety. But for a tool with a required, undocumented ID parameter and a project-scoping parameter, the description leaves the discovery workflow (list first, then get) unstated.

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 50%: project_id is well documented in the schema (including the get_scope pointer), but volume_id has no description. The description only restates 'by ID' without adding format, source, or lookup guidance, so it fails to compensate for the gap.

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 ('Get one volume by ID'), and the singular 'one ... by ID' implicitly distinguishes it from the sibling list_volumes. It does not, however, differentiate from get_volume_attachment or explain scope relative to project listing.

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 list_volumes (to find an ID first) or get_volume_attachment (for attachments). An agent must infer the workflow entirely from tool names.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description correctly reinforces a safe read. The phrase 'without connection details' adds genuine value by warning that connector data is excluded, but nothing is said about permission requirements or error behavior for a missing ID.

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 key scope caveat ('without connection details') is placed where it will be read.

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?

Output schema exists, so return values needn't be described, and the annotations carry the safety profile. For a two-parameter read tool the description is nearly sufficient, with only the project scoping left entirely to the 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 50%: project_id is documented in the schema, while attachment_id carries only length constraints. The description clarifies that the ID identifies the record to fetch, adding marginal meaning over the bare schema, consistent with the baseline for partial coverage.

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

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

The description states a specific verb and resource ('Get one Cinder attachment record') and scopes it to a single record by ID, which implicitly separates it from list_volume_attachments. It doesn't name the list sibling explicitly, so it stops short of full 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?

The 'one ... by ID' phrasing implies a single-record lookup versus enumeration, but there is no explicit statement of when to prefer this over list_volume_attachments or get_volume. Guidance is inferable, not 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 cover the safety profile (readOnly, idempotent, non-destructive), and the description goes beyond them by disclosing the auth-role requirement and decoding the forbidden response ('forbidden means the role is missing, not that the list is empty') — a genuinely useful behavioral cue. The 'Not paged' claim is slightly at odds with a limit parameter, but the added operational context still outweighs that.

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 short, front-loaded sentences with no filler; the resource and return fields come first, followed by caveats. The trailing 'Not paged; narrow with filters' is slightly compressed to the point of ambiguity given the presence of a limit parameter.

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 a full output schema, the description covers the important gaps: permission requirements, what a 403 means, and pagination expectations. Nothing essential for a correct call is missing.

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 the limit and project_id parameters are already fully described in the schema, establishing the baseline of 3. The description's 'narrow with filters' adds nothing, and neither parameter is actually a filter, so it does not enrich parameter meaning.

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 Nova host aggregates') and adds the returned content ('with availability zone and hosts'), which lets an agent know what to expect. There is no near-identical sibling to distinguish from, so no explicit differentiation is needed.

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

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

The description gives a prerequisite ('Usually needs more than a project reader role') and tells the agent to 'narrow with filters', which implies usage context. However, it never states when to choose this tool over another or what a typical call scenario looks like, leaving guidance largely implicit.

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?

Adds substantial context beyond the readOnly/idempotent annotations: the elevated role requirement and the crucial error semantics ('forbidden means the role is missing, not that the list is empty'), which prevents an agent from misreading an auth failure as an empty result. It also discloses the no-pagination behavior, so the agent knows a single call returns everything.

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 tight sentences with zero filler, each carrying a distinct payload (what it lists, auth/error semantics, pagination and filtering). The most decision-relevant facts come first.

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?

An output schema exists, so return values need not be explained, and the description covers the non-obvious risks: permissions and forbidden-vs-empty interpretation. The only real gap is not spelling out what host and binary filter on, which would round out an otherwise complete definition.

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 50%: limit and project_id are documented in-schema, while host and binary are bare. The description's 'narrow with filters' hints at the filtering intent but never names host or binary, so the two undocumented parameters remain ambiguous. This matches the baseline 3 for a schema that does half 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?

Names a specific verb and resource ('List Nova services such as nova-compute') and states the returned fields (host and state), which separates it from the volume/network service siblings. It stops short of explicitly contrasting with the similarly named list_services, so the agent must infer the OpenStack distinction.

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

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

Provides useful operational guidance: 'Usually needs more than a project reader role' and 'Not paged; narrow with filters.' However, it never tells the agent when to pick this over list_services or list_volume_services, leaving the key sibling choice implicit.

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 readOnly/idempotent/non-destructive, and the description adds value on top: it discloses an authorization prerequisite ("usually needs more than a project reader role") and clarifies that a forbidden result signals a missing role rather than an empty list, which prevents a costly misreading. The hedged "usually" softens the guarantee, and return-shape details are left to the output schema.

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

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

Three short sentences with zero filler, and the identifying purpose is front-loaded ahead of the operational caveats. Every sentence carries distinct information (identity, auth/error semantics, paging).

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?

Because an output schema exists, return values need no explanation, and the description covers the two things that schema cannot: authorization behavior and the absence of paging. The only shortfall is the unexplained `name` filter, which leaves an agent guessing at match semantics.

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 67%: limit and project_id are documented in the schema, but `name` has no description anywhere. The phrase "narrow with filters" hints at filtering but never explains whether name is an exact match, substring, or glob, so the description does not compensate for the one gap that remains.

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

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

The description opens with a specific verb+resource ("List Keystone domains"), which is clearly distinct from sibling tools like list_projects or list_servers. It does not explicitly name any sibling, but the resource is unambiguous, so an agent won't confuse it with anything else in the catalog.

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 provides real invocation context: the role requirement, how to interpret a forbidden response, and the advice to narrow with filters instead of paging. There are no competing alternatives to disambiguate, but it also gives no explicit 'when not to use' guidance, keeping it at a strong 4 rather than a 5.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds two genuinely useful behaviors: an elevated role is usually required, and 403/forbidden means a missing role rather than an empty result. The "not paged" note also prevents a wrong pagination assumption. Return shape is left to the output schema.

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

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

Three short, front-loaded sentences with no filler; the scope statement comes first and the caveats follow. The opening phrase "with interface and URL" is slightly ambiguous about whether interface is a filter or a returned field.

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 output schema covers return values and annotations cover the safety profile, so the remaining burden is parameter meaning. For a five-parameter filtered list where three filters are undocumented anywhere, the description leaves an agent guessing how to narrow the result.

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

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

Schema coverage is only 40%: interface, region_id and service_id have no schema descriptions, and the description does not explain them at all. "Narrow with filters" is a generic gesture that never says which filter to use for which narrowing goal, so the description fails to compensate for the coverage gap.

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 Keystone catalog endpoints") and notes the fields returned. It does not, however, distinguish this from the sibling list_services, which an agent could easily confuse with catalog endpoints.

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?

"Not paged; narrow with filters" plus the role caveat gives clear operational context for when and how to call it. It stops short of naming an alternative (e.g. list_services) for the case where the catalog view is the wrong resource.

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, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description adds genuinely useful context beyond that: results are scoped by project visibility and field units are stated (MiB for RAM, GiB for disk), but it says nothing about ordering or auth/permission 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?

Two short sentences, front-loaded with what the tool returns and what the fields mean. The second sentence mostly restates the paging parameters already in the schema, so it is slightly redundant but far from wasteful.

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

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

For a simple, zero-required-parameter list tool with an output schema and full annotation coverage, this is close to sufficient: scope, field semantics and paging are all addressed. Only ordering of results and any permission requirements are left unstated, which are minor gaps 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%, so limit, marker and project_id are already fully documented in the schema, including the next_marker paging convention and the get_scope pointer. The description mentions limit and marker but adds no syntax or defaults beyond the schema; 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 flavors') and enumerates the attributes returned (vCPUs, RAM, disk), which tells an agent exactly what this returns. It does not explicitly differentiate itself from siblings like list_images or list_servers, though the collection-per-resource naming makes disambiguation largely self-evident.

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

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

The description implies usage (list the flavors visible to the project) and notes the result is paged, but gives no explicit when-to-use vs. when-not guidance and names no alternative tool. Given there is no get_flavor sibling, the implied usage is at least unambiguous.

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, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds only the pagination behavior ('Paged with limit and marker'), which the schema already states, and says nothing about result ordering, page size limits, or empty results.

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 short sentences, front-loaded with what is returned. The second sentence largely restates schema-level pagination detail, so it is efficient but not maximally informative per word.

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?

Return shape is covered by the output schema, but three filter parameters are undocumented anywhere, and an agent cannot tell that status, port_id and floating_network_id are available as filters. For a six-parameter listing tool that is a material omission.

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

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

Schema coverage is 50%: limit, marker and project_id are documented, but status, port_id and floating_network_id have no description in either the schema or the tool description. The description mentions only limit and marker, which are already fully documented, so it fails to compensate for the gap.

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 the project's floating IPs') plus the useful detail that the ports they map to are included. Sibling tools operate on different resources (subnets, ports, routers), so differentiation is inherent, but the description does not explicitly contrast with list_ports even though floating IPs map to ports.

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 list tool versus get_port or list_ports for the mapping question, and no note on when filtering by status/port is appropriate. The only usage-adjacent content is the pagination note.

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 destructiveHint=false, so the safety profile is covered; the description still earns credit by disclosing the elevated role requirement and explaining that a forbidden response means a missing role rather than an empty result. It also states that the call is not paged, which is real behavioral context 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?

Three short sentences with the core purpose front-loaded and no filler. The final sentence about filters is the weakest — it is short but points at capability that does not exist in the schema, so it does not fully earn 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?

An output schema exists, so return-value detail is unnecessary, and the description covers the two non-obvious operational facts an agent needs: the privilege requirement and the absence of pagination. The unresolved gap is that "narrow with filters" implies filtering options that the tool does not offer.

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 are already fully documented in the schema and the baseline applies. The description's only nod to parameters is "narrow with filters," which adds no meaning and is mildly inconsistent with a schema that exposes no filter beyond limit and project_id.

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 Nova hypervisors" — plus what the result carries (state and capacity), which distinguishes it from generic siblings like list_services or list_compute_services. It stops short of explicitly contrasting with those nearest neighbors, so the 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?

The description gives a prerequisite and an error-decoding rule, but never says when to choose this over list_compute_services or the per-resource get_* tools. Usage context is implied at best, and "narrow with filters" points at filtering that the schema barely supports (only limit and project_id).

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 readOnly, idempotent, openWorld, and non-destructive behavior. The description adds scope ('visible to the project') and pagination mechanism, but does not provide richer behavioral context beyond that.

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

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

The description is two brief sentences with no wasted words and front-loads the core operation. Its brevity is appropriate, though it borders on under-specification for the filter parameters.

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

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

An output schema exists and annotations cover safety, reducing the description's burden. However, for a six-parameter list tool with several undocumented filters, the description leaves meaningful gaps about what can be filtered.

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

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

With 50% schema description coverage, the description should clarify the remaining filter parameters, especially name, status, and visibility. Instead, 'optionally filtered' is vague and the limit/marker mention merely restates schema descriptions.

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

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

The description clearly states the action and resource: listing images visible to the project. It also notes optional filtering and paging, but does not explicitly distinguish this tool from the singular sibling get_image.

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 only says images can be 'optionally filtered' without naming filters or explaining when to use list_images versus get_image. There is no explicit guidance on alternatives or when-not to use it.

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

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

Goes well beyond the annotations: it discloses the RBAC prerequisite (usually more than a project reader role), how a 403 should be read (missing role, not an empty result), and that the operation is not paged. Those are exactly the traits that change an agent's behaviour on failure and result-size assumptions.

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 short sentences, each carrying a distinct fact, with the core purpose front-loaded and the auth caveat before the paging note. No filler.

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

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

An output schema exists, so return values need no explanation, and the description covers auth, error semantics and paging. The remaining hole is what values host and agent_type accept, which leaves the agent guessing at filter syntax.

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 50% – limit and project_id are documented in the schema, but host and agent_type have no descriptions anywhere. The description only gestures at them with 'narrow with filters' and gives no hint about accepted agent_type values, so it does not compensate for the gap.

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?

Specific verb plus resource ('List Neutron agents') with the returned fields named ('host and liveness'). The 'Neutron agents' qualifier implicitly separates it from the compute/volume/identity service listers in the sibling set, so an agent can pick it out without opening the schema.

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

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

'Narrow with filters' is the only usage steering, and it neither names which filters nor points at alternatives such as list_compute_services or list_services when the wrong agent family is needed. The forbidden-means-missing-role note is useful but is error interpretation rather than when-to-use guidance.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description contributes the pagination trait ('Paged with limit and marker'), though that is also visible in the schema's limit/marker fields, and adds nothing about result ordering or the status filter's effect.

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 short sentences with the primary behavior front-loaded. The second sentence on paging largely restates what limit and marker already document, so it is slightly redundant but not wasteful.

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 has no required parameters and an output schema, so return format need not be described. The main remaining gap is the undocumented status filter and any default ordering, but overall the description is sufficient to invoke correctly.

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

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

Schema coverage is 80%, so the schema already explains limit, marker, shared and project_id in detail. The description only echoes limit/marker paging and the shared flag, and says nothing about the undocumented status parameter or the allowed status values.

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 the project's networks') and adds the shared-network variant, which distinguishes the two listing modes. It does not differentiate itself from siblings like list_subnets or get_network, but the resource 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 shared=true alternative is named, giving partial routing guidance, but the description never says when to use this instead of get_network (single lookup) or how it relates to list_subnets. Usage is implied rather than 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, openWorldHint and destructiveHint=false, so the safety profile is fully covered. The description earns some credit for stating that results include fixed IPs and security groups and that paging is marker-based, but it says nothing about result size limits, ordering, or what an empty project looks like.

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 short sentences, front-loaded with the resource and its notable payload, followed by the paging contract. No filler and nothing to trim.

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 output schema and annotations relieve the description of return-format and safety duties, and pagination is covered. But for a 6-parameter tool with four optional filters, an agent reading only the description would not know filtering exists — a meaningful completeness gap given the sibling set is filter-heavy.

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 67%, so the schema does most of the work; the description mirrors only the two paging parameters. It never mentions the filtering parameters, and the status enum (ACTIVE/DOWN/BUILD/ERROR) has no description in the schema either, leaving that filter's effect undocumented everywhere.

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 the project's ports') and adds what the records carry ('fixed IPs and security groups'), so the agent knows this is a collection read rather than a detail read. It does not explicitly contrast with get_port or list_networks, but the list/get naming convention makes the split reasonably clear.

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

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

The only usage guidance is the pagination mechanic ('Paged with limit and marker'). Nothing tells the agent when to prefer this over get_port for a single port, or that the tool supports server-side filtering by status, device_id, network_id and project_id — arguably the most decision-relevant fact about a list endpoint.

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

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

With annotations already declaring readOnlyHint=true, idempotentHint=true, and destructiveHint=false, the description adds meaningful behavior: authorization can fail with 'forbidden' even when results would not be empty, and the result set is not paged. It does not describe return shape, but an output schema exists.

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

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

The description is three short sentences, front-loads the purpose, and uses the remaining space for non-obvious operational guidance. There is no wasted text.

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

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

For a read-only list tool with rich annotations and an output schema, the description covers the key non-obvious risks: permissions, 'forbidden' interpretation, and lack of pagination. The main remaining gap is that filter parameters are not 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?

Schema description coverage is only 50%, and the description does not map 'filters' to the actual parameters. The name and domain_id parameters lack schema descriptions, and the description does not explain their semantics or filtering behavior beyond the generic instruction to 'narrow with filters.'

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

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

The description opens with a specific verb and resource: 'List Keystone projects.' That is enough to identify it as a project-listing tool, though it does not explicitly differentiate it from project-adjacent siblings such as list_domains or get_scope.

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

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

It provides useful operational context: role requirements, the meaning of 'forbidden', that results are not paged, and that filters should be used to narrow results. However, it does not explicitly say when to use this versus alternatives like get_scope or other 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 destructiveHint=false, so the safety profile is covered. 'Not paged' is genuine added behavioral information, but it sits oddly next to a limit parameter capped at 100, leaving the actual truncation behavior ambiguous.

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 short sentences, front-loaded with the resource, with no filler. The second sentence is terse to the point of ambiguity about how limit interacts with non-paging, but it is efficiently placed.

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?

An output schema exists so return values need no explanation, and the schema covers both parameters. However, the 'Keystone regions' terminology is unexplained and 'not paged' conflicts with the presence of a limit, leaving a real behavioral question open for an agent deciding how many results to expect.

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 limit (1-100, default 50) and project_id (omit for default project; values from get_scope) are fully documented in the schema. The description adds nothing about parameters, 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 Keystone regions'), which is unambiguous against the sibling list_* tools that target subnets, ports, servers, etc. It does not explicitly name a sibling or contrast itself, but the resource noun alone is sufficient differentiation here.

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 sibling get_scope or the other listing tools, and no mention of the project_id scoping choice beyond what the schema says. The reader is left to infer usage entirely from 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 readOnly, idempotent and non-destructive, so safety is covered. The description adds real behavioral context beyond them: the call is not paged and a complete=false value signals the router has more interfaces, which tells the agent how to detect truncation. It does not explain how limit interacts with that 'not paged' claim, which is the one loose end.

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 short sentences with zero filler; the resource scope is front-loaded and the truncation caveat follows. Every clause carries information the agent 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?

An output schema exists, so return shape need not be explained, and the description covers the one thing the schema cannot: how to tell the list was truncated. The only gap is the relationship between the limit parameter and the stated 'not paged' 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 coverage is 67%: limit and project_id carry descriptions (project_id even points to get_scope), but router_id is undocumented in both schema and description. The description adds nothing about parameter meaning, so the baseline 3 for mid-coverage schema 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?

States a specific verb and resource ('List a router's internal interfaces') and enumerates what an interface contains (port, subnet, IP), which lets an agent distinguish it from the broader list_ports sibling. It stops short of explicitly naming the alternative, so sibling routing still requires inference.

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

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

Usage is implied by the resource name: call this when you need the interfaces attached to a specific router, rather than all ports. There is no explicit 'when to use this vs list_ports' statement and no stated preconditions (e.g., that the router must exist or that router_id must come from list_routers).

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, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds that results include gateway and static route data, which hints at payload richness, but says nothing about ordering, filtering behavior, or how pagination termination works beyond 'paged'.

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 short sentences with no filler, and the resource scope is front-loaded ahead of the pagination note. The secondary line about paging is slightly fragmentary but still 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?

With an output schema present, return-value explanation is unnecessary, and the annotations cover safety. However, for a tool exposing four optional parameters, the description never mentions the status filter or project_id scoping, leaving an agent to rely entirely on the schema for selection logic.

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 75% and the schema itself documents limit, marker, and project_id; only 'status' lacks a description. The description mentions limit/marker pagination but never explains the status filter or project scoping, so it adds no meaning beyond the schema. 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 clear verb+resource ('List the project's routers') and adds scope detail that the routers carry gateway and static routes, which distinguishes it from get_router and from list_subnets/list_networks. It does not explicitly name the sibling alternative, keeping it below 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 pagination note ('Paged with limit and marker') implies iterative listing, and the plural resource implies enumeration rather than single-record retrieval versus get_router. There is no explicit when-to-use/when-not guidance or named alternative.

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, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds that results include security group rules and are paged, but it does not mention authorization requirements, project defaulting behavior, or pagination termination details. This is adequate but not rich contextual disclosure.

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

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

The description is two short sentences, front-loads the core action, and has no wasted text. The pagination note is compact and appropriately placed after the main purpose.

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

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

An output schema exists, so return values need not be explained. The description gives enough context to understand the resource, included rules, and pagination model. The main gap is the unexplained `name` filter, but the overall definition is nearly complete for a zero-required-parameter listing 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 75%, with limit, marker, and project_id already documented in the schema. The description repeats the paging concept via "Paged with limit and marker" but adds no semantics beyond the schema, and it does not explain the `name` parameter, which is not described in 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 uses a specific verb and resource: "List the project's security groups with their rules." That clearly distinguishes this as a collection-listing operation, and the phrase "with their rules" adds useful scope. It does not explicitly contrast with get_security_group, but the sibling naming pattern makes the distinction reasonably clear.

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

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

The description contains no when-to-use guidance, no exclusions, and no alternative-tool routing. It implies usage through the verb "List," but the agent is not told when to use this rather than get_security_group or another sibling.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety profile is covered. The description's useful addition is that results are pre-joined with flavor, image, addresses and volumes, but it says nothing about whether deleted/shelved servers appear by default or what happens when project_id 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?

Two short lines, front-loaded with the purpose and the returned fields, then the paging note. No filler sentences.

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?

An output schema exists and annotations are rich, so the description doesn't need to explain return values; covering purpose plus enrichment fields and paging is close to sufficient. The only gap is routing against get_server and the semantics of the unmentioned status filter.

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

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

With 80% schema coverage, the schema already documents name, limit, marker and project_id. The description only restates the paging parameters and never mentions the status filter or its enum values, 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?

States a specific verb and resource ("List servers") and adds what the records are enriched with (flavor, image, addresses, volumes), which distinguishes it from the singular get_server sibling. It doesn't explicitly name get_server as the detail-fetch alternative, but the list/detail split is clear enough from the wording.

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?

"Paged with limit and marker" is the only procedural hint, and that repeats what the schema already documents. There is no guidance on when to use this versus get_server, or on how the name/status filters interact.

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?

Goes well beyond the readOnlyHint/idempotentHint annotations by disclosing the authorization requirement ('usually needs more than a project reader role') and decoding the error semantics ('forbidden means the role is missing, not that the list is empty') — a distinction an agent would otherwise misread. It also states the result set is not paged, which shapes how the agent should size and iterate calls.

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 short sentences, each carrying distinct information: identity, permission/error semantics, and result-set behavior. Purpose is front-loaded and nothing is redundant.

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

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

For a read-only list tool with full schema coverage and an output schema, the description covers the non-obvious risks (auth role, forbidden semantics, no pagination). Only minor gaps remain, such as how limit truncates an unpaged result 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 coverage is 100%, so all three parameters are already documented, making 3 the baseline. The description adds a mild clarification that results are not paged and should be narrowed via filters, but it doesn't explain how limit interacts with the unpaged claim or what type values are realistic beyond the schema's 'compute' example.

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 services registered in the Keystone catalog'), which cleanly separates it from the many list_* siblings such as list_compute_services and list_volume_services. It does not explicitly name those siblings, so differentiation is inferable 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?

Offers implied guidance ('narrow with filters') and useful prerequisites around role requirements, but never says when to prefer a sibling like list_endpoints or list_compute_services, nor any exclusion condition. Adequate for a straightforward list tool but lacking explicit routing.

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, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the pagination contract (limit + marker), which is genuinely useful behavioral context, but says nothing about auth/permissions or result ordering. With annotations carrying the load, a 3 is appropriate.

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

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

Two short sentences, front-loaded with the resource and return fields, then the pagination note. No filler; the only slight waste is that the pagination sentence duplicates schema-documented parameters.

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

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

An output schema exists, so return values needn't be described, and annotations cover safety. However, with two filter parameters undocumented in both schema and description, an agent cannot confidently use ip_version or network_id filtering without guessing.

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 only 60%: limit, marker and project_id are documented, but ip_version and network_id have no description anywhere. The description repeats limit/marker pagination (already in the schema) and never mentions that results can be filtered by IP version or narrowed to a specific network — the two parameters an agent most needs explained.

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 the project's subnets') and adds the fields returned (CIDR, gateway, DHCP settings), which is more than a restatement of the title. It does not explicitly distinguish itself from get_subnet or list_networks, but the list-vs-get distinction is inferable from the name pair.

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 only usage signal is 'Paged with limit and marker' — pagination mechanics, not when-to-use guidance. Nothing says when to prefer this over get_subnet (single subnet) or list_networks (parent objects), nor any prerequisite such as needing a project context.

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld. The description adds genuinely new behavioral facts: connection details are excluded from the response, a minimum microversion is required, and results are paged. It does not explain what happens when filters like volume_id are omitted, which is the remaining gap.

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 short sentences with zero filler; the resource identity and the microversion constraint are front-loaded and the pagination note follows. Nothing is redundant with the schema or annotations.

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?

An output schema exists, so return shape need not be explained, and the description covers the two non-obvious call-level facts (microversion floor, paging) plus a response exclusion. It stops short of explaining the filter parameters, which is the only material omission.

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

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

Schema coverage is 80%, so the baseline is 3. The description adds the pagination idiom ("paged with limit and marker"), reinforcing how marker pairs with next_marker, but says nothing about volume_id, project_id, or instance_id semantics — those rely on schema text (and volume_id has none).

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

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

States a specific verb and resource ("List Cinder attachment records") plus a meaningful scope constraint (API microversion 3.27 or later). The plural 'list' vs. the sibling 'get_volume_attachment' is implied by naming, but the description never explicitly contrasts them or says whether it covers all volumes or one.

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

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

The microversion note tells the agent when the call is valid, but there is no guidance on when to prefer this over list_volumes or get_volume_attachment, nor any prerequisite/auth context. Usage is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and openWorld behavior, so the safety profile is covered. The description adds the paging mechanism, which is useful context, but doesn't disclose return format or filtering behavior beyond the safety metadata.

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

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

Two short, front-loaded sentences with zero filler. The scope and returned fields come first, followed by the pagination note.

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?

An output schema exists, so return values needn't be re-explained. The description covers scope and pagination adequately for a list tool, with the only minor gap being undocumented name/status filters.

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 60%: limit, marker, and project_id carry schema descriptions, while name and status have none. The description only reinforces the paging semantics already in the schema and does not explain the name or status filters, so it does not compensate for the coverage gap.

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 volumes') plus scope ('in the project') and the fields returned (size, type, attachments). It does not explicitly distinguish itself from siblings like get_volume or list_volume_attachments, though the list-vs-get naming is intuitive.

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?

Mentions pagination via limit and marker, implying usage for browsing collections, but offers no explicit when-to-use guidance, no exclusions, and no routing to alternatives such as list_volume_attachments when attachments are the focus.

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?

Goes well beyond the annotations by explaining a key failure mode ('forbidden means the role is missing, not that the list is empty') and the absence of paging. Minor tension: 'Not paged' sits awkwardly against a schema that exposes a limit parameter with a 1-100 cap, leaving the agent to guess whether limit truncates or pages.

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 short sentences, each carrying distinct information, with the resource and return fields front-loaded. The trailing 'Not paged; narrow with filters' is telegraphic enough to be slightly ambiguous rather than maximally 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?

Covers purpose, authorization pitfalls, error interpretation, and paging behavior; an output schema exists so return-shape detail is unnecessary. The remaining hole is the undocumented host/binary filter semantics and how limit interacts with the no-paging claim.

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 50%: limit and project_id are documented in the schema, while host and binary are bare. The description hints at filtering and implies binary names ('such as cinder-volume'), but never says what values binary accepts or that host is an exact-match filter, so it only partially compensates for the coverage gap.

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 Cinder services such as cinder-volume') plus what is returned (host and state). The 'Cinder/volume' qualifier distinguishes it cleanly from list_compute_services, list_network_agents, and list_services without needing to name 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?

Gives real operating context: the call usually requires more than project reader, and 'Not paged; narrow with filters' tells the agent how to get useful result sets. It does not explicitly name a sibling alternative for the compute/network variants, which keeps it below a 5.

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