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

No annotations are provided, and the description only states that it returns a JSON string with availability zones information. It does not disclose read-only behavior, authentication requirements, or any side effects. The description carries the full burden and is insufficient.

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

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

The description is very short (two lines) and front-loaded with the purpose. However, it could be slightly more informative while still concise. It is not bloated, but it lacks detail.

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

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

Given that the tool has no parameters and an output schema exists, the description is minimally adequate. However, it could mention that the output returns status information. Compared to the sibling complexity, it is incomplete in guiding the agent on when to use this tool.

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

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

The tool has zero parameters, so the schema already covers everything. The description adds no extra parameter information, but with no parameters, the baseline is 4. It does not detract but also does not add value beyond the schema.

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

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

The description states 'List availability zones and their status', which clearly indicates the action and resource. However, it does not explicitly differentiate from the sibling tool 'get_load_balancer_availability_zones', which could cause confusion despite being contextually different.

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

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

No guidance is provided on when to use this tool versus alternatives, such as the load balancer-specific availability zones tool. There is no mention of prerequisites or exclusions.

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

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

No annotations are provided, so the description carries full burden. It describes read-only operations like listing and showing capacity, but does not explicitly state that the tool is non-destructive or has no side effects. It is clear enough but lacks explicit safety 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 concise with a clear header, bullet points for functions, example queries, and return type. It is front-loaded with the main purpose. Slightly verbose with 'Functions:' and 'Use when user requests:' 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?

Given zero parameters and an existing output schema, the description provides sufficient context on what the tool does and what information it returns. It covers pool capacity and utilization, which is relevant for floating IP allocation.

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

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

Input schema has no parameters, so the baseline is 4. The description adds value by explaining what the output contains (capacity information) and the purpose of the returned data.

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

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

The description clearly states it gets a list of floating IP pools, with specific verb 'Get' and resource 'floating IP pools'. It distinguishes from siblings like get_floating_ips by focusing on pools and capacity.

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

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

The description provides example user queries indicating when to use the tool, such as 'Show floating IP pools' and 'Check floating IP capacity'. However, it does not explicitly mention when not to use or alternatives among siblings.

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

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

No annotations are provided, so the description carries the behavioral transparency burden. The description adequately implies a read-only operation via the 'get' verb and lists what information is returned, but does not explicitly state that it is safe or describe any side effects.

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

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

The description includes some redundancy, with bullet points that essentially repeat the main function. It is structured but could be more concise.

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

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

The tool is simple with no parameters and has an output schema (indicated). The description mentions the return format and covers the necessary context for a straightforward list 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?

The input schema has no parameters, so coverage is 100%. The description does not need to add parameter semantics. According to guidelines, zero-parameter tools have a baseline score of 4.

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

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

The description clearly states that the tool returns a list of floating IPs with associations. However, it does not explicitly differentiate from sibling tools like get_floating_ip_pools, which is a closely related tool.

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

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

The description provides usage context ('when user requests floating IP information, external connectivity queries, or IP management tasks'), but lacks exclusions or mention of alternative tools for specific scenarios.

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

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

With no annotations, the description carries full burden. It indicates a read-only operation and mentions return format (JSON) and functions (query status, timestamps, etc.), but lacks details on permissions, rate limits, or pagination 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?

Description is front-loaded with key purpose and includes a bullet list of functions, but has some redundancy (e.g., 'Get list' in title and description). Could be slightly more concise.

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

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

Given zero parameters and an output schema present, the description sufficiently explains what the tool does and returns. However, it does not mention if results are paginated or limited, which would enhance completeness.

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

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

No parameters exist, so schema coverage is 100%. Description adds no param info, which is acceptable since there are none. Baseline 4 applies.

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

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

The description clearly states the verb 'Get' and resource 'list of Heat orchestration stacks', with specific functions listed. It distinguishes from sibling tools like get_instance or get_routers by focusing on orchestration stacks.

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

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

Explicitly states 'Use when user requests stack information, orchestration queries, or infrastructure-as-code status', providing clear context. However, it does not mention when not to use or suggest alternatives among the many siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not deliver: it does not confirm this is a read-only operation, does not mention required permissions or whether 'all' could be expensive, and says nothing about the nature of the returned details. An output schema exists, which relieves it of explaining return values, but the safety and cost profile remains undisclosed.

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

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

One sentence with no wasted words and the resource front-loaded. However, the brevity comes at the cost of under-specification rather than genuine economy.

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

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

For a simple one-parameter read tool with a full output schema, the minimum needed to call it correctly is present. Missing are the behavioral cues normally expected when no annotations exist: read-only confirmation and the cost of requesting all hypervisors.

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

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

Schema description coverage is 100% and the single parameter is fully documented, including the 'all' default. The description adds nothing beyond that, which meets the baseline for high-coverage schemas.

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

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

States a verb ('Get') and resource ('hypervisors') so the target is unambiguous, but 'detailed information' is vague about what details are returned. Unlike siblings such as get_load_balancer_details, the description gives no hint of scope or content, so differentiation rests entirely on the resource noun.

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

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

No statement of when to use this versus alternatives, and no prerequisites or exclusions. The only scoping hint is the schema's 'all' default, not the description itself.

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

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

No annotations are provided, so the description carries the burden. It states the tool returns a comprehensive list with metadata but does not disclose potential volume, pagination, or performance implications. The read-only nature is implied by 'get' but not explicitly stated.

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

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

The description is somewhat verbose with bullet points and a separate 'Returns' section that largely duplicates the initial sentence. It could be more concise by merging the first sentence and summary.

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

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

Given no parameters and no annotations, the description adequately explains what the tool does and its output (metadata, properties, status). It does not mention pagination or rate limits, but for a simple list tool without filters, it is sufficient.

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

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

The tool has zero parameters, and schema coverage is 100% (trivially). The description adds value by confirming no input is needed and explaining the output scope ('all images'). This clarifies the tool's lack of filtering options, which is helpful.

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

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

The description explicitly states 'Get detailed list of all images with comprehensive metadata' and lists specific functions (status, size, format). It clearly distinguishes from sibling tools which target other resources like volumes, instances, or load balancers.

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

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

The description provides explicit usage context: 'Use when user requests image listing, image information, or image metadata details.' This clearly indicates when to invoke this tool, though it does not mention when not to use it or suggest alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It discloses supported retrieval modes, pagination, and summary/detailed output, but does not state that the operation is read-only, how multiple filters interact, or any permission/rate-limit considerations.

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

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

The description is front-loaded with its unified purpose and then lists concrete supported functions. It is efficient overall, though the function list and final usage sentence have some overlap.

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

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

Given 100% schema coverage and an output schema, the description does not need to explain return values. It adequately summarizes the main retrieval patterns for a ten-parameter tool, though it could clarify filter precedence and the relationship to duplicate sibling tools.

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

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

Schema coverage is 100%, so the schema already documents all ten parameters. The description adds useful pattern-level grouping (by names/IDs, status, search fields, pagination), but does not add syntax, precedence, or combination semantics beyond what the schema provides.

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

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

The description states a specific resource and verb ('Unified instance query tool') and enumerates retrieval patterns it supports. It also names the sibling tools whose functionality it consolidates, which helps distinguish it, though those siblings still appear as separate tools and no explicit selection rule is given.

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

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

It gives a clear usage condition: 'Use when user requests instance information, status checks, or instance searches.' However, it does not explicitly say when to use this consolidated tool versus the still-present specialized siblings such as get_instance_details or search_instances.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: not whether instance names are unique, what happens when the name is not found (error vs empty), or whether any permissions are required. The presence of an output schema excuses it from describing return fields, but the missing-not-found behavior is a real gap for a lookup tool.

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

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

A single front-loaded sentence with zero waste and the lookup key surfaced early. It is appropriately sized, though there is little content to be concise about given the omitted guidance.

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 one documented parameter and an output schema covering return values, the definition is minimally servable. The unresolved ambiguity against get_instance, get_instance_details, and search_instances in a crowded namespace is the main completeness gap an agent would care about.

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?

Only one parameter exists and the schema documents it fully at 100% coverage ('Name of the instance to retrieve'), so the schema does the work. The description adds nothing beyond restating the parameter, matching the baseline 3 for high-coverage schemas.

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

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

States a specific verb and resource ('Get detailed information for a specific instance') plus the lookup key ('by name'), so the operation itself is unambiguous. However, it does not distinguish itself from the closely related siblings get_instance, get_instance_details, and search_instances, leaving the agent to guess which instance accessor to pick.

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

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

There is no explicit when-to-use statement, no exclusions, and no mention of when to prefer the ID-based get_instance or the broader search_instances. The 'by name' phrasing faintly implies the ID-based alternative, but the agent must infer that from the tool 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?

No annotations are provided, so the description must carry the behavioral burden. It does disclose pagination behavior and large-scale support, and implicitly signals a read operation, but it never states that results are returned as a collection, whether the query is scoped to a project, or what the cost of the include_all-style bulk path is beyond the schema's own warning.

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 purpose is front-loaded, which is good, but the five-bullet 'Functions' list contains filler that restates the schema ('Support large-scale environments with configurable limits') and mixes 'basic instance information' against the 'detailed' framing. A tighter two-sentence description would serve better.

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 is present, so return values need not be explained, and all parameters are fully described in the schema. The remaining need is purpose and usage framing, which the description supplies, making it complete enough 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 description coverage is 100%, so all six parameters are already documented in the schema, and the description adds only a general note about 'configurable limits' and pagination. It does not explain the relationship between instance_ids, instance_names, all_instances, and include_all, which is the one place narrative could have added real value.

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

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

The description states a clear verb+resource (retrieve detailed information and status for OpenStack instances) and enumerates the specific data it returns (network/IPs, CPU/memory/storage, metadata, keypair, security groups). However, it does not differentiate itself from close siblings like get_instance, get_instance_by_name, get_instances_by_status, or search_instances, and the bullet 'Query basic instance information' partially undercuts the 'details' framing of the name.

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

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

The closing sentence gives usage triggers (VM details, server analysis, instance troubleshooting), which is better than nothing. But those triggers overlap almost entirely with what get_instance, get_instance_by_name, and search_instances would also claim, and no alternative or exclusion is named despite four closely related siblings.

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

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

No annotations are provided, so the description carries the full behavioral burden. The word 'Get' implies a read operation, but the description does not disclose pagination, permissions, or other read-behavior details beyond the operation type.

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

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

The description is a single front-loaded sentence with no redundant or wasted wording. It is appropriately sized for a simple filtered-list tool.

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

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

The tool is simple, has a fully described single parameter, and has an output schema, so the description is sufficient for invocation. However, it lacks context for selecting this tool over sibling tools such as search_instances.

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 single parameter has 100% schema description coverage, including example status values. The description repeats that filtering is by status but adds no syntax or format details beyond the schema, fitting the baseline of 3 when schema coverage is high.

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

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

The description gives a clear verb and resource: it gets instances and filters them by status. It is specific enough to distinguish the tool from generic instance retrieval, but it does not explicitly differentiate it from the sibling tool search_instances.

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

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

The description implies the tool is used when filtering by status, but gives no explicit guidance on when to use it versus search_instances or other sibling tools. There are no exclusions or prerequisites.

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

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

No annotations are provided, so the description carries full burden. It describes the return content (fingerprints, types, dates, truncated public key) but does not explicitly state that the operation is read-only or any authentication requirements. The name implies a read operation, but transparency is moderate.

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

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

The description is well-structured with bullet points and sections (Functions, Use when, Returns). It is concise and front-loaded with the main purpose. Minor redundancy could be trimmed but overall efficient.

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

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

For a tool with no parameters and an output schema (implied), the description covers the purpose, usage scenarios, and return content. Missing explicit read-only declaration or auth notes, but it is generally complete for a simple list tool.

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

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

No parameters exist, so schema coverage is 100%. The description adds context about the returned fields (fingerprints, types, dates), which adds value beyond the empty schema.

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

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

The description states 'Get list of SSH keypairs for the current user' which is a clear verb+resource combination. It further enumerates specific information returned (fingerprints, types, dates, public key). Among sibling tools, this is distinct from other get_* tools (e.g., get_security_groups, get_volume_list).

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

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

The description explicitly says 'Use when user requests SSH key management, keypair information, or security key queries.' This provides clear context, though it does not mention when not to use or alternatives.

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

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

No annotations are provided, so the description carries the full burden, yet it only implies a read via the verb 'Get'. It says nothing about permissions/scope required, whether the result includes amphora health or status, or behavior when the LB has no amphorae; only the output schema partially compensates.

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. Minor redundancy between 'amphora instances' and 'all amphorae', but nothing 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 one-optional-parameter read tool with an output schema, the description is barely sufficient: return contents are covered by the output schema, but with no annotations the description should at least confirm the operation is read-only and note what permissions or LB state it depends on.

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

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

Schema description coverage is 100% and the single optional parameter already documents the empty-string-means-all behavior. The description merely restates that dual mode and adds no format hints (name vs. UUID, required prefix) 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 ('Get amphora instances') and covers both scopes: for a named load balancer or all amphorae. It is distinguishable from the many get_load_balancer_* siblings because amphorae is a distinct resource, though it doesn't explicitly contrast itself with get_load_balancer_details or get_load_balancer_list.

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 'or all amphorae' clause implies the two usage modes and the schema makes the empty-string case explicit, but there is no guidance on when to prefer this over sibling load balancer tools or any stated prerequisites (e.g., requiring an LB ID from get_load_balancer_list).

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

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

No annotations are present, so the description should disclose behavioral traits. It only states it returns a JSON string, but does not indicate if the operation is read-only, requires authentication, or has any side effects.

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

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

The description is extremely concise with two sentences and no wasted words. It is front-loaded with the purpose.

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

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

Given no parameters and an existing output schema, the description is minimal but could be more helpful by clarifying the scope relative to the sibling tools and the meaning of availability zones in this context.

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

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

The tool has no parameters, so the schema coverage is 100%. The description adds no additional meaning beyond what the schema already provides, but given the lack of parameters, it is minimally sufficient.

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

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

The description clearly states the verb 'Get' and resource 'load balancer availability zones', making the purpose apparent. However, it does not differentiate from the sibling tool 'get_availability_zones', which may cause confusion.

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

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

No guidance is provided on when to use this tool versus alternatives, such as get_availability_zones. There is no mention of prerequisites or context for use.

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

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

No annotations are provided, so the description carries the burden, and it does disclose the composite nature of the call: it aggregates listeners, pools/members, and health monitors in one response, which tells an agent this is a heavier read than a single-resource fetch. Read-only semantics are implied by "Get"/"Shows", but permissions, not-found behavior, and cost of the aggregation are not stated.

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?

Front-loaded with the purpose, then two scannable bullet groups (Functions, Use when). The four trigger phrases are slightly repetitive but each maps to a distinct query pattern; there is no filler or redundancy 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?

With an output schema present, return values needn't be described in detail, and one required parameter is fully documented. The description is sufficient to call the tool correctly; only error/edge behavior (nonexistent LB, empty listeners) is unaddressed.

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

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

Schema coverage is 100% with a single required parameter whose description ("Load balancer name or ID") already covers it. The description adds nothing about acceptable formats (UUID vs. name, ambiguity resolution) beyond what the schema states, so baseline 3 applies.

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

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

States a specific verb and resource ("Get detailed information about a specific OpenStack load balancer") and enumerates exactly what detail is bundled: VIP config, listeners, pools/members, health monitors, status. It doesn't explicitly name a sibling like get_load_balancer_list as the alternative, but "specific" vs. the sibling list tool is readily 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?

The "Use when user requests" block gives four concrete trigger utterances (show details, get configuration, show listeners/pools, check status), which maps well to how an agent routes natural-language requests. It lacks explicit when-not/exclusion guidance pointing to get_load_balancer_listeners, get_load_balancer_pools, etc., for narrower lookups.

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

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

No annotations provided and the description only states it returns a JSON string. It lacks disclosure of behavioral traits such as read-only nature, authentication needs, or performance characteristics. The word 'Get' implies read-only, but no explicit details.

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

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

The description is concise with two sentences, front-loading the purpose. It could be slightly more structured but is not verbose.

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

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

Given no parameters and presence of an output schema, the description is mostly adequate. However, it does not explain what 'flavors' are or how the result relates to other load balancer operations, which could help overall context.

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

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

With zero parameters and 100% schema coverage, the description adds minimal value but does not need to. Baseline for 0 parameters is 4; the description confirms there are no inputs, which is consistent.

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

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

The description explicitly states 'Get load balancer flavors', clearly identifying the verb and resource. It distinguishes from sibling tools like get_load_balancer_amphorae or get_load_balancer_availability_zones.

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

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

No guidance on when to use this tool versus alternatives. The description does not specify context, prerequisites, or exclude cases, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description must carry behavioral disclosure. The verbs 'Get' and 'Lists' plus the enumerated output fields make clear this is a non-mutating read, and the Functions list usefully previews what the response contains. However, it says nothing about permissions/auth requirements, result volume, or pagination behavior.

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

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

The lead sentence is front-loaded and the two bulleted lists are scannable rather than prose-heavy. There is mild redundancy between the Functions list and the trigger-phrase list, but each section serves a different reader need and no sentence is pure filler.

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

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

For a single-optional-parameter read tool with an output schema, the definition covers purpose, return contents, and invocation triggers adequately, so return-value explanation is rightly left to the schema. The remaining gap is edge-case behavior, such as what happens when the supplied pool name or ID does not match any pool.

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

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

Schema description coverage is 100% for the single optional parameter, and the schema already documents the 'empty for all' convention. The description only restates the pool filtering at a high level, adding no format hints (e.g., name vs. UUID resolution) beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource ('Get health monitors') plus scope ('optionally filtered by pool'), and the Functions list enumerates exactly what is returned (monitor types, intervals, timeouts, HTTP settings). This makes the tool clearly distinct from adjacent siblings like get_load_balancer_pools or get_load_balancer_pool_members, though no sibling is named 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 'Use when user requests' section gives four concrete trigger phrases covering both the unfiltered ('Show all health monitors') and filtered ('List health monitors for pool [name/id]') cases. It lacks any explicit when-not-to-use guidance or named alternative tools, which keeps it from 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?

No annotations are provided, so the description carries the full behavioral-disclosure burden. 'Get' implies a read operation, but it says nothing about permissions, pagination, result size, or other operational traits; the output schema helps with return values, but the description itself is minimal.

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

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

The definition is a single, front-loaded sentence with no wasted words. It states the resource and the optional filtering scope immediately.

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

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

For a simple read tool with one optional, fully documented parameter and an output schema, the description supplies enough context to invoke it correctly. The main gap is the absence of guidance on when to prefer this tool over related L7 rules or listener tools.

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

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

Schema description coverage is 100%, so the listener_name_or_id parameter is already fully documented as optional and empty-means-all. The description mirrors that behavior ('for a listener or all L7 policies') but does not add format, identification, or filtering details beyond the schema.

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

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

The description states a specific verb and resource (Get L7 policies) and gives the scope (for a listener or all policies). It is clear enough to distinguish from siblings like get_load_balancer_l7_rules by resource name, though it does not explicitly call out when this tool should be chosen over that sibling.

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

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

The description implies the optional filter behavior: pass a listener to scope policies, or omit it to retrieve all. It does not state when to use this tool versus alternatives such as get_load_balancer_l7_rules or get_load_balancer_listeners, so the usage guidance remains 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?

No annotations are provided, so the description carries the burden; 'Get' implies a safe read, but it says nothing about permissions, pagination, or behavior when the policy has zero rules. An output schema exists, which relieves it of explaining return structure, so the remaining gap is moderate rather than severe.

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

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

One short sentence, front-loaded with the verb and resource, with the scoping condition stated immediately. There is no filler 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?

For a single-required-parameter read tool with full schema coverage and an output schema, the description covers what is needed to select and call it. Only the absence of any hint about empty-result behavior keeps it from being fully complete.

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

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

Schema description coverage is 100% and the single parameter is already documented as 'L7 policy name or ID (required)'. The description only restates that the value identifies a specific policy, adding no format, lookup, or resolution semantics beyond the schema.

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

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

The description states a specific verb ('Get') and resource ('L7 rules') scoped to an L7 policy, which distinguishes it from the sibling get_load_balancer_l7_policies that returns policies rather than rules. It stops short of explicitly naming that sibling or contrasting the two.

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?

Mentioning 'for a specific L7 policy' implies a policy identifier is required and that this is a drill-down call after listing policies, but it never states when to use this versus get_load_balancer_l7_policies or what happens if the policy has no rules.

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

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

With no annotations, the description carries the behavioral burden and does disclose useful traits: it lists all load balancers, includes VIP/status/listener information, supports pagination, and shows provisioning and operating status. The read-only nature is strongly implied by 'Retrieve', 'Lists', and 'Shows', though it is not explicitly declared as non-destructive.

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

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

The description is front-loaded and organized into useful sections for capabilities and user requests. It is slightly repetitive in restating listing and detail behavior, but the examples and bullet structure earn their place.

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

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

For a read-only list tool with a rich input schema and an output schema, the description gives enough context to invoke it correctly for listing and status inspection. The main remaining gap is sibling differentiation from get_load_balancer_details and listener-specific tools, but the core operation is well covered.

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

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

Schema description coverage is 100%, so the schema already documents limit, offset, and include_all precisely. The description adds only general pagination context via limit/offset and does not mention include_all or add format details beyond the schema, making 3 the appropriate baseline.

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

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

The description clearly states that this tool retrieves a list of all OpenStack load balancers with detailed information, including VIP, status, and listeners. It is distinguishable as the list-all tool, but it does not explicitly contrast itself with the sibling get_load_balancer_details or subresource tools such as get_load_balancer_listeners.

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 'Use when user requests' section gives clear example phrases that map to listing and status-checking scenarios. However, it does not state when not to use this tool or point to alternatives like get_load_balancer_details for a single load balancer or get_load_balancer_listeners for listener-specific queries.

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

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

With no annotations, the description carries the full behavioral burden. It clearly implies a read-only listing operation and describes returned fields (protocols, ports, admin state, timestamps), but it does not disclose permissions, pagination, or error behavior.

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

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

The purpose is front-loaded and the bullet structure is easy to scan. There is some redundancy between the opening sentence, the 'Lists all listeners' function line, and near-duplicate usage examples, but the definition remains reasonably tight.

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

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

For a simple read-only tool with one fully described parameter and an output schema, the description provides enough purpose, output-field context, and usage examples to call it correctly. Minor operational details like pagination or not-found behavior are absent but not critical.

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

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

There is only one parameter, and schema description coverage is 100%. The description does not add syntax or format detail beyond the schema's 'Load balancer name or ID', so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: getting listeners for a specific OpenStack load balancer. It distinguishes the resource from sibling load balancer tools implicitly, though it does not explicitly name alternatives like pools or health monitors.

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 explicit 'Use when user requests' examples that map user intent to this tool. However, it does not state when not to use it or name a sibling alternative for related listener-adjacent questions.

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

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

No annotations are provided, so the description carries the full burden, and it does reasonably well: it enumerates the returned data (addresses, ports, weights, health status, admin/operational state, monitor config), making clear this is a read-only enumeration. It does not mention behavior for a nonexistent pool, pagination, or permissions.

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?

Front-loaded one-sentence purpose followed by an optional function list and phrasing examples; each block is useful and skimmable. The 'Functions' bullets partially overlap with the opening sentence, adding mild redundancy.

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

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

With an output schema present, the description need not document return shape, and it still summarizes the visible fields. For a one-parameter read tool with no annotations this is nearly complete; only error/empty-result behavior is unaddressed.

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

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

Single parameter at 100% schema coverage, so the schema already explains 'pool_name_or_id'. The description only implies the argument via 'a specific ... pool' and adds no format hints or accepted-ID notes beyond what the schema states.

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

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

Opens with a specific verb+resource: 'Get members for a specific OpenStack load balancer pool.' This is clearly distinct from siblings like get_load_balancer_pools, though it doesn't explicitly state the relationship (use get_load_balancer_pools to discover a pool, then this tool to enumerate members).

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 'Use when user requests' block gives four concrete, quoted invocation phrases, which makes selection easy. It lacks any when-not guidance or pointer to alternatives (e.g. get_load_balancer_pools for listing pools or get_load_balancer_health_monitors for pool-level health).

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?

Annotation coverage is zero, so the description carries the full burden; it does disclose that results include protocols, algorithms, member statuses, and health monitor associations, and the 'Get/Lists/Shows' framing implies a read-only operation. However, it says nothing about permissions, pagination, or behavior when the listener filter matches nothing.

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 main purpose is front-loaded in the first line and the function bullets are scannable. The four quoted user phrases are somewhat repetitive padding, but each is short and supports retrieval matching.

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

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

For a one-parameter read tool with an output schema and full schema coverage, the description covers what is returned at a useful level of detail. Only minor gaps remain (filter-miss behavior, pagination) and are not critical for correct invocation.

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

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

Schema description coverage is 100% and the single parameter is already documented as an optional listener name/ID filter. The description's phrase 'optionally filtered by listener' merely restates the schema, so baseline 3 is appropriate.

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

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

States a specific verb and resource (get load balancer pools) plus the filter scope, which is clear and distinct from the sibling get_load_balancer_pool_members. It does not explicitly name that sibling as the alternative for member-only queries, but the primary purpose is unambiguous.

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

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

The 'Use when user requests' block with four verbatim example queries gives an agent concrete triggers for selecting this tool. There is no explicit 'do not use when' or named alternative, so it stops short of a 5 despite clear usage context.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It only states that the tool returns a JSON string, omitting any side effects, authentication needs, or rate limits. As a read operation, it lacks necessary behavioral context.

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

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

The description is extremely concise, using a single sentence and a line about the return type. It is front-loaded and contains no unnecessary words, earning its place efficiently.

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

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

Given the tool has no parameters and an output schema exists, the description is nearly complete for its simplicity. However, it could briefly explain what load balancer providers are to improve completeness.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter meaning, but it correctly implies no input is required.

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

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

The description clearly states the tool gets load balancer providers, with a specific verb and resource. It distinguishes it from sibling tools which target other resources. However, it does not clarify what 'providers' means in this context.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention any prerequisites or context where this tool is appropriate, leaving the agent without decision criteria.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it is thin: 'Get' implies a read, but nothing is said about permission/admin requirements, whether empty project_id triggers a cross-project listing that could be expensive, or what the quota values represent.

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

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

A single well-formed sentence with no wasted words and the scope qualifier placed up front. It is minimal but not padded.

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 the single parameter is fully documented, so return values and param meaning need not be restated. The only real gap is the absence of guidance relative to the similar get_quota sibling.

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

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

Schema coverage is 100% and the schema already documents that an empty project_id means all projects; the description merely restates that same contrast. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb and resource ('Get load balancer quotas') plus the scoping dimension ('for a project or all projects'). It is distinguishable from the sibling get_quota (generic quotas) and from get_load_balancer_list, though it never names those alternatives.

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

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

Usage is only implied: the phrase 'for a project or all projects' hints at when the parameter is omitted, but there is no explicit statement about when to call this instead of get_quota or get_load_balancer_details, and no prerequisites 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?

With no annotations, the description carries the full behavioral burden. It does disclose the data collected (config info, subnet IP allocation, router connection status, security group rules and port info), which is useful. It does not state that the operation is read-only (implied by 'get'/'Provides'), nor mention scope limitations such as whether routers/SGs are included only when referenced by the network.

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

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

It is front-loaded with the core purpose, then a compact bullet list of covered resources, followed by a usage line. The bullet list partly restates the opening sentence, but overall it is efficient and appropriately sized.

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 single optional parameter is fully documented in the schema. The description sufficiently conveys what is retrieved for a read-only query tool, though it could better clarify boundaries with the router and security-group siblings.

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

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

Schema description coverage is 100% and there is a single optional parameter with a documented default ('all'), so the schema does the heavy lifting. The description adds no syntax, format, or default behavior details 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?

The first sentence states a clear verb and resource set ('Provides detailed information for OpenStack networks, subnets, routers, and security groups'), so an agent knows roughly what it returns. However, it does not distinguish itself from siblings such as get_routers and get_security_groups, leaving ambiguity about whether those are covered here or should use the dedicated tools.

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

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

The final sentence gives usage scenarios ('network information, subnet details, router configuration, or network troubleshooting'), which implies when to call it. But there are no exclusions or alternatives named, and the overlap with get_routers/get_security_groups is unresolved, so an agent cannot confidently route between them.

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