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 implies read-only analysis but does not explicitly state safety, idempotency, or side effects. The mention of 'analyzes' suggests no mutations, but it is not explicit.

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 reasonably concise with the core purpose front-loaded, but the inclusion of a conflicting args section and a 'Returns' line that likely duplicates output schema info reduces efficiency. Every sentence should be earned.

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?

Even with an output schema, the tool fails to provide context on when to compare performance vs. get individual metrics. The misleading args section and lack of usage guidance leave the agent underinformed 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?

The input schema declares zero parameters, but the description lists 'Args: settings: Application settings'. This directly contradicts the schema, confusing agents. Schema coverage is 100% but the description adds misleading information.

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 compares performance metrics across all sites, listing specific metrics like uptime, latency, bandwidth, and health status. However, it does not explicitly distinguish itself from similar sibling tools such as 'get_cross_site_statistics' or 'get_internet_health'.

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, nor are there any prerequisites or exclusions mentioned. The description is purely declarative.

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

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

With no annotations, the description discloses the destructive nature (DELETE) and safety mechanisms (confirm required, dry_run available). However, it omits details like authentication needs, rate limits, and consequences of execution. The mention of 'settings' param not in schema is confusing.

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 relatively concise but includes an undocumented parameter (settings), which reduces clarity. It could be better structured with separate sections for behavior and 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?

Given the lack of annotations and the existence of an output schema, the description covers key safety and testing features (confirm, dry_run). However, it does not explain return values beyond 'raw response or preview', and the 'settings' discrepancy undermines completeness.

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

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

Schema coverage is 0%, so description adds meaning for three of four actual parameters (console_id, path, confirm, dry_run). It explains dry_run as preview without sending. However, it erroneously includes 'settings' which is not in the schema, and does not clarify the confirm parameter's type mismatch (allows string but description says boolean).

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 proxies a DELETE request to the Network Application via Cloud Connector, accurately reflecting its purpose and distinguishing it from sibling tools like connector_network_get, patch, post, and put.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., POST for creation, PUT for updates). The description only explains parameters, not usage context 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 description carries full burden. It states the request is forwarded and returns raw response, and lists raised exceptions (ValidationError, ValueError). However, it mentions a 'settings' parameter that does not appear in the input schema, creating confusion about tool 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 structured with Args/Returns/Raises sections, which aids readability. However, it includes a parameter ('settings') not present in the schema, adding confusion. It could be more concise by removing the erroneous 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?

Given the tool's complexity as a proxy GET, the description covers the basic behavior and error cases. It references output schema implicitly ('raw response'), but lacks details on pagination or response structure. More context on how path relates to the Network API would improve completeness.

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

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

Schema coverage is 0%, so description must explain parameters. It describes 'console_id' and 'path' with examples and 'params' as optional query parameters. However, it also lists a 'settings' argument that is not in the schema, which is misleading and contradictory. This reduces effectiveness.

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

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

Description clearly states it proxies a GET request to the Network Application via Cloud Connector, specifying the verb and resource. It differentiates itself from sibling tools that handle other HTTP methods (DELETE, PATCH, POST, PUT) for the same connector.

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?

Description implies usage for retrieving data from the Network API via proxy but does not explicitly state when to use this tool versus alternatives. It mentions required settings (UNIFI_SITE_MANAGER_ENABLED) but lacks guidance on 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?

Discloses that 'confirm' must be true to execute and supports dry_run. However, lacks annotations and does not detail side effects, authorization requirements, or rate limits. For a PATCH operation, it provides basic but not complete behavioral transparency.

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

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

Relatively concise, listing arguments and return value. However, the inclusion of a non-existent 'settings' parameter wastes words and reduces efficiency.

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

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

Given the tool's complexity (5 params, no annotations, output schema exists but not described), the description leaves gaps: no explanation of response format beyond 'raw response', no error handling info, and no context for the 'dry_run' preview.

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 0% schema description coverage, the description attempts to explain parameters but includes 'settings' which is not in the schema, creating confusion. It also fails to describe the 'body' parameter's structure or the exact meaning of 'path' sub-path.

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 proxies a PATCH request to the Network Application, which distinguishes it from other HTTP methods like PUT. However, the mention of a 'settings' parameter not present in the schema slightly muddies the purpose.

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

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

No explicit guidance on when to use this tool versus siblings (e.g., connector_network_put). The description implies it's for partial updates, but does not state when-not or provide 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 discloses mutation behavior (confirm required), dry-run capability, and error conditions. However, it omits authentication needs, rate limits, or side effects beyond mutation.

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 Args, Returns, Raises sections and a clear summary sentence. It is appropriately detailed without excessive verbosity.

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

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

Given 5 parameters and no annotations, the description covers most behaviors (mutation, dry-run, errors) but lacks details on rate limits, network dependencies, and does not clarify the extra 'settings' parameter.

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 description adds meaning to parameters via docstring but introduces a 'settings' parameter not present in the input schema, causing inconsistency. Schema coverage is 0%, so the description partially compensates but with a discrepancy.

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 'Proxy a POST request to the Network Application via Cloud Connector,' specifying verb, resource, and distinguishing from sibling HTTP method tools (delete, get, patch, put).

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 explains the need for 'confirm' to execute the mutation and 'dry_run' to preview, but does not explicitly contrast with alternatives like GET or other tools.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions confirm as a safety mechanism and dry_run for preview, but omits details about side effects, idempotency, authentication, or rate limits. Additionally, the description lists a 'settings' parameter that is not present in the input schema, introducing inconsistency.

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 and uses a clear bullet list for parameters. However, the inclusion of an undocumented 'settings' parameter slightly reduces clarity. Overall, it is well-structured and 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 5 parameters, no annotations, and 0% schema coverage, the description should fully cover usage. It addresses most parameters but misses format guidance (e.g., path syntax, console_id pattern) and has the settings discrepancy. The output schema is mentioned but not detailed.

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 0% schema description coverage, the description must compensate. It explains console_id, path, body, confirm, and dry_run, but includes 'settings' which is not in the schema, causing confusion. The explanations are brief and lack formatting details.

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 'Proxy a PUT request to the Network Application via Cloud Connector,' which specifies the verb (PUT), resource (Network Application), and mechanism (Cloud Connector). This distinguishes it from sibling tools like connector_network_get, connector_network_post, etc.

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 explains key usage with parameters: confirm ('Must be True to execute') and dry_run ('Preview without sending'). While it doesn't explicitly compare to other methods, the HTTP method in the name implies its use case for updates/creations.

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 fully disclose behavior. It mentions confirm and dry_run parameters but fails to describe authentication, rate limits, side effects, return value details, or error scenarios. The mention of a non-existent 'settings' parameter further reduces transparency.

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

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

The description is short and front-loaded, listing arguments and return value efficiently. The structure is clear, but the inclusion of an extra parameter ('settings') introduces unnecessary noise.

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

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

Given the complexity of a proxy tool (network request, destructive action) and lack of output schema details, the description is incomplete. It omits error handling, response structure beyond 'raw response or preview', and important behavioral context like idempotency or prerequisites.

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 0%, so the description must compensate. It explains console_id, path, confirm, and dry_run, adding meaning beyond the schema. However, it includes a 'settings' parameter not in the schema, misleading about available inputs. This inconsistency lowers reliability.

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 proxies a DELETE request to the Protect Application via Cloud Connector, distinguishing it from other HTTP methods. However, it mentions a 'settings' argument not present in the input schema, which could 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?

The description does not provide any guidance on when to use this tool versus alternatives (e.g., other HTTP methods). It lacks context on prerequisites, when not to use it, or how it fits into a workflow.

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?

Without annotations, the description discloses the forwarding behavior and raises, but does not cover rate limits, idempotency, or side effects. The mention of required site manager settings adds some 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 well-structured with sections for arguments, returns, and raises, and is concise without fluff.

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

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

Given the existence of an output schema and the proxy nature, the description covers the main purpose and basic behavior, but lacks detail on authentication and header forwarding.

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 description provides context for console_id and path, and mentions params, but includes a 'settings' parameter not in the input schema, causing confusion. Schema coverage is 0%, so the description adds some but incomplete 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 clearly states it proxies a GET request to the Protect Application via Cloud Connector, distinguishing it from sibling tools with different HTTP methods.

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

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

The description implicitly differentiates usage via its HTTP method name and sibling names (e.g., connector_protect_delete), but lacks explicit guidance on when to use this tool vs 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?

Discloses that 'confirm' must be True to execute and 'dry_run' provides preview, but lacks details on mutation effects, authentication needs, or error behavior. With no annotations, more transparency would be beneficial.

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 concise with clear Args and Returns sections. It efficiently conveys the tool's purpose and key parameters without unnecessary 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?

Despite having an output schema (not shown), the description leaves out details about how the proxy works, the meaning of 'path', the role of 'settings', and error handling. The missing schema parameter further reduces 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?

Adds meaning to schema parameters (e.g., console_id as host identifier, path as sub-path) beyond their names. However, it introduces a 'settings' parameter not in the schema, reducing clarity and consistency.

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 proxies a PATCH request to the Protect Application, distinguishing it from GET/POST/DELETE/PUT siblings. However, it lists a 'settings' parameter not present in the input schema, causing minor 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 on when to use this tool versus alternatives like connector_protect_put or connector_protect_post. The description implies it's for PATCH operations but doesn't specify use cases 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 the full burden. It discloses key behavioral traits: the need for 'confirm' to execute, the 'dry_run' preview feature, and the proxy nature. However, it lacks details on authentication requirements or error handling.

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 separate Args and Returns sections, and the purpose is front-loaded. However, it includes an extraneous parameter ('settings') and 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 no annotations and a moderate complexity (5 params), the description covers the basic operation and preview mode but omits error handling, required permissions, and rate limits. The output schema exists and is partially addressed.

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 description adds meaning for most parameters (e.g., path, body, confirm, dry_run) but includes a 'settings' parameter that does not exist in the input schema, creating confusion. With 0% schema description coverage, this inconsistency reduces usability.

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 ('Proxy a POST request') and the resource ('Protect Application via Cloud Connector'), distinguishing it from sibling tools like connector_protect_get or connector_protect_delete.

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

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

The description implies usage for sending POST requests to Protect API sub-paths but does not explicitly state when to use POST vs other methods (GET, PUT, DELETE) or compare with siblings. No alternative tools are mentioned.

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

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

No annotations provided, so description carries full burden. It discloses dry_run and confirm behavior, and states the return type. However, it does not cover potential side effects, authentication needs, rate limits, or error handling, leaving gaps in transparency.

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

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

The description is concise, with a clear purpose statement and bulleted parameters. It is front-loaded and avoids redundancy. Every sentence adds value, though the 'settings' line could be removed or corrected.

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 (not shown), the description adds return type info. But it omits prerequisites, error scenarios, and integration details. Given the tool's complexity as a proxy request, it is moderately complete but could include more 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?

Schema description coverage is 0%, so description must compensate. It adds meaning for parameters like console_id, path, body, confirm, dry_run, but mentions a 'settings' parameter not present in schema, causing confusion. Overall, it provides useful context but has an inconsistency.

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 'Proxy a PUT request to the Protect Application via Cloud Connector,' which is a specific verb and resource. It distinguishes from sibling tools like connector_protect_get, connector_protect_post, etc., by indicating the HTTP method and target application.

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 guidelines: confirm must be True to execute, dry_run for preview. It does not explicitly compare to alternatives (e.g., when to use PUT vs POST), but the parameter instructions add clarity for correct usage.

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

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

The description mentions a 'settings' parameter, but the input schema has no properties, creating a contradiction. Without annotations, the description fails to disclose any behavioral traits such as idempotency, side effects, or required 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?

The description is short but includes unnecessary docstring formatting. The contradiction between description and schema suggests it was not carefully reviewed. It is not a model of conciseness due to the error.

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

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

Despite having an output schema (not shown), the description lacks details about what the aggregate statistics contain or how they are computed. The parameter mismatch further reduces 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 description includes a parameter 'settings: Application settings' that does not exist in the input schema. This is misleading and adds conflict rather than clarity. Schema coverage is 100% because no params, but description adds erroneous information.

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 aggregate statistics across multiple sites. It is specific about the verb 'get' and the resource 'cross-site statistics', but it does not differentiate from potentially similar sibling tools like 'list_all_sites_aggregated' or 'search_across_sites'.

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. There are many sibling tools with overlapping functionality, but the description provides no context for selection.

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

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

Annotations are absent, so the description carries full burden. It discloses nothing beyond the core action: it's a read operation (get). It does not mention side effects, authentication needs, rate limits, or error handling (e.g., if host_id not found). This is insufficient for a tool with no annotation support.

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 (one line plus arg/return notes). It is front-loaded with the core action. However, it is under-specified and lacks detail, making it less useful than a longer, more informative description would be.

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

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

Given the tool's simplicity (one param, likely returns a host object) and the presence of an output schema, the description could still be more complete. It omits any mention of error cases, response formats, or unique behavior. In a context with many sibling tools, more context would aid selection.

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 one parameter, host_id, with no description (0% coverage). The description adds 'Host identifier,' which is essentially a restatement of the parameter name. It provides no additional semantic value, such as format, constraints, or examples.

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

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

The description clearly states the tool's purpose: 'Get host details by ID.' This distinguishes it from sibling tools like list_hosts (which returns all hosts) and get_site_details (different resource). The verb-resource pair is specific and unambiguous.

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

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

No guidance is provided on when to use this tool vs alternatives. There is no mention of prerequisites, exclusions, or scenarios where another tool would be more appropriate. The description simply states what it does without 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 present, and the description does not disclose any behavioral traits such as read-only nature, authentication requirements, or rate limits. It merely states what the tool does.

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 short but contains unnecessary and incorrect information (the 'settings' arg). It could be more concise by removing the misleading line.

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

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

While an output schema exists, the description provides only a vague 'Returns: Client details'. The omission of the 'settings' parameter from the schema is not addressed, leaving the agent confused about parameter expectations.

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 description only lists parameter names without adding meaning. Moreover, it includes a non-existent 'settings' parameter, which contradicts the schema and misleads the agent.

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

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

The verb 'get' and resource 'single connected client' clearly indicate the tool's purpose. However, the description mentions a 'settings' parameter that is not in the input schema, causing slight 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 its sibling 'list_integration_clients'. There is no mention of prerequisites or alternatives.

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

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

Annotations are absent, so the description must fully disclose behavioral traits. It indicates a read operation ('Get') but adds no details about auth requirements, error handling, rate limits, or consequences. Furthermore, it mentions a 'settings' parameter not present in the input schema, creating a misleading inconsistency.

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 relatively short and front-loaded with the main purpose. However, the inclusion of an extra parameter and the 'Args'/'Returns' structure adds unnecessary length. A more streamlined description would be preferable.

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 2 required parameters and no schema descriptions, the description should be more complete. It omits error conditions, required permissions, and relationship to sibling tools. The output schema exists but does not cover behavioral 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?

Schema coverage is 0%, so description is critical. It explains site_id and device_id minimally ('Site identifier', 'Device UUID') but also includes a nonexistent 'settings' parameter, which harms clarity and accuracy. The descriptions for actual parameters are too terse to aid correct usage.

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

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

The description clearly states the tool retrieves a single adopted device via the integration API. The verb 'get' and the resource 'single adopted device' are specific. It distinguishes from listing tools like list_integration_devices but does not explicitly differentiate from similar get tools like get_host.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not specify prerequisites, exclusions, or context in which this tool is preferred over sibling 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?

With no annotations, the description must fully disclose behavior. It correctly indicates a read operation ('Get') but does not mention any side effects, permissions, or rate limits. The return details are vague.

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 brief but includes an extraneous parameter ('settings') not in the schema, which harms accuracy. It would be improved by removing the misleading line.

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 presence of an output schema, the description adequately conveys the primary purpose but lacks details on error handling, required permissions, or the scope of 'DNS policy details'.

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

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

The description provides basic meaning for 'site_id' and 'policy_id' but incorrectly includes 'settings: Application settings' which is not in the input schema. This inconsistency reduces clarity.

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 'Get a single DNS policy' using a specific verb and resource, distinguishing it from the sibling 'list_integration_dns_policies' tool which retrieves multiple policies.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'list_integration_dns_policies'. There is no mention of prerequisites or contextual usage.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does not mention that the tool is read-only, authentication requirements, rate limits, or any side effects. The return is vaguely described as 'WiFi broadcast 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 fairly concise but includes an erroneous parameter ('settings'). The structure is clear with arguments listed, but the extra parameter wastes space.

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

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

For a simple get tool with two parameters, the description lacks essential details like that site_id and broadcast_id are required, and does not explain the output structure despite having an output schema. No usage hints are provided.

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 0%, so the description should clarify parameters. It repeats obvious names for site_id and broadcast_id but adds a non-existent 'settings' parameter not in the schema, causing confusion and reducing 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 'Get a single WiFi broadcast via the integration API,' clearly specifying the verb and resource. It distinguishes from the sibling tool 'list_integration_wifi_broadcasts' which retrieves multiple broadcasts.

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, such as listing broadcasts. The description does not provide context for when a single get is appropriate or when to fall back to 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 provided, and the description lacks behavioral disclosures such as side effects, authentication needs, or rate limits. For a read-like tool, it only states what it does without any transparency about limitations or behaviors beyond the basic function.

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 relatively short but includes an unnecessary 'Args' section that lists a non-existent 'settings' parameter, making it slightly less structured. It front-loads the purpose but wastes space on incorrect parameter documentation.

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

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

Given the tool's simplicity (one parameter, output schema exists), the description covers the basic functionality. However, the misleading 'settings' argument and lack of details about the return structure (despite output schema being present) leave it incomplete for an autonomous agent looking for precise invocation 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 description adds meaning to the 'site_id' parameter by explaining that None yields aggregate metrics. However, it incorrectly lists 'settings: Application settings' as an argument, which does not appear in the input schema (only site_id is present). This misalignment reduces the value added and could confuse an agent.

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 'Get internet health metrics across sites', specifying the verb (Get) and resource (internet health metrics). It hints at aggregation behavior by mentioning 'site_id' optionality, which slightly distinguishes it from sibling tools like get_site_health_summary or get_isp_metrics, though not explicitly.

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

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

The description provides usage guidance by indicating that site_id is optional and that omitting it returns aggregate metrics. However, it does not specify when to prefer this tool over similar siblings like compare_site_performance or get_cross_site_statistics, leaving room for ambiguity.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions return data types (bandwidth, latency, jitter, packet loss) but does not cover side effects, required permissions, or rate limits. Adequate but incomplete.

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 (4 lines), front-loaded with the action, and contains only essential information. No wasted words.

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

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

Given low complexity (1 param) and presence of output schema, the description is adequate but could be improved by noting common use cases or mentioning sibling tools. Lacks guidance for comprehensive 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?

Schema description coverage is 0%; the description only restates the parameter name 'site_id' as 'Site identifier' without adding meaning or format. The return description does not compensate for parameter semantics.

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

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

The description clearly states the tool's action ('Get ISP metrics') and its target ('for a specific site'), distinguishing it from siblings like query_isp_metrics which may be more general.

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

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

No explicit guidance on when to use this tool versus alternatives like query_isp_metrics or compare_site_performance. The description lacks context for appropriate usage 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?

No annotations are provided, and the description does not disclose any behavioral traits such as read-only, destructive potential, or authorization needs. Merely states it returns configuration 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 but includes an extra Args section that does not match the schema, reducing clarity. The Returns line is empty. It is front-loaded but not entirely accurate.

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

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

For a simple get-by-ID operation, the description is minimal. It does not explain behavior on missing IDs, error handling, or provide details about the output despite an output schema existing. The mismatch between Args and schema further detracts from 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 description lists two parameters ('settings', 'config_id') in the Args block, but the input schema only contains 'config_id' as a required property. This mismatch misleads about available parameters. Schema description coverage is 0%, so the description fails to add meaningful semantic 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?

Clearly states 'Get SD-WAN configuration by ID', using a specific verb and resource. Distinguishes from siblings like 'list_sdwan_configs' and 'get_sdwan_config_status'.

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

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

Implies usage for retrieving a specific config by ID, but lacks explicit guidance on when to use this tool versus alternatives, or any 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 must fully disclose behavioral traits. It only states it gets status but does not mention side effects, permissions, rate limits, or whether it's a safe read operation. Minimal 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 includes an 'Args:' section with 'settings' which does not exist in the schema, making it inaccurate. A true concise description would not include extraneous or incorrect 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?

The tool is simple with one required parameter and an output schema, but the description fails to explain the return value, possible statuses, or additional context needed for correct invocation. It is incomplete.

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

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

Schema description coverage is 0%, so the description must add meaning. It describes 'config_id' as 'Configuration identifier', which is minimally helpful. More critically, it lists a non-existent parameter 'settings: Application settings', contradicting the schema and misleading the agent.

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 'Get SD-WAN configuration deployment status', using a specific verb ('Get') and resource ('SD-WAN configuration deployment status'). This distinguishes it from siblings like 'get_sdwan_config' and 'list_sdwan_configs'.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions that a ResourceNotFoundError is raised for missing sites and returns a dictionary, which is helpful. However, it does not state whether the tool is read-only, any side effects, authorization requirements, or performance characteristics.

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 relatively short and structured with Args, Returns, Raises sections. It is efficient but could be more concise by removing redundant phrasing. Overall, it is well-organized and front-loaded with the core purpose.

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

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

The description covers the basic return type and error condition. Since an output schema exists, the return values may be detailed there. However, the description lacks information about what 'detailed site information' includes, and the parameter is minimally described. The tool is simple, so this is adequate but not 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 schema has 0% description coverage for the parameter 'site_id'. The description's Args section says 'Site identifier', which adds minimal meaning beyond the schema. No additional context like format, examples, or constraints is provided.

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

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

Description states 'Get detailed site information', which clearly identifies the tool's purpose as retrieving site details. The verb 'get' and resource 'site details' are specific. However, it does not differentiate from sibling tools like get_site_health_summary or get_site_inventory, leaving ambiguity about what 'detailed' includes.

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 siblings. There is no mention of prerequisites, when to avoid, or alternative tools. The description is purely functional with no 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 provided, so description carries burden. It discloses that setting site_id to None returns summary for all sites, but lacks details on authentication, rate limits, or data freshness.

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 brief and uses a structured Args/Returns format. It is front-loaded with the main purpose. Could be slightly more concise by removing the erroneous 'settings' line.

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

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

For a tool with one optional parameter and an output schema (not shown), the description adequately covers purpose and parameter behavior. However, it lacks guidance on when to choose this tool over many similar 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?

Description explains site_id parameter meaning and default behavior, which adds value over the schema (0% coverage). However, it misleadingly includes 'settings: Application settings' in Args, which is not in the input schema, causing confusion.

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

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

The description clearly states 'Get health summary for all sites or a specific site', using a specific verb and resource. It distinguishes from siblings by noting optional site_id for individual site vs. all sites.

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 context (with or without site_id) but does not explicitly guide when to use this tool over siblings like get_site_details or get_cross_site_statistics.

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 indicates the tool retrieves inventory (read operation) and lists components, but does not disclose potential permissions, data size implications, or whether it is cheap or expensive to call. The 'comprehensive' nature suggests a potentially heavy operation, which is not warned about.

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 a clear purpose sentence, a bullet list of included resources (though not in markdown), and standard Args/Returns sections. It could be slightly more concise by removing the redundant 'Args' and 'Returns' labels if not needed, but overall it is efficient.

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

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

With only one parameter and an output schema (not shown but indicated), the description provides adequate context: return type (site inventory or list of site inventories) and the scope of data. The tool is simple, and the coverage is sufficient.

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

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

Schema description coverage is 0%, but the description adds meaningful context: it explains the site_id parameter is optional and that omitting it returns inventory for all sites. This goes beyond the schema's 'anyOf' type and default null.

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

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

Description starts with a specific verb ('Get') and resource ('comprehensive inventory for a site or all sites'), and the bullet list of components clearly distinguishes it from sibling tools that retrieve individual elements (e.g., list_sites, get_site_details) or focus on performance (compare_site_performance).

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 explains the optional site_id parameter and its behavior ('If None, returns inventory for all sites'), but does not explicitly state when to prefer this tool over alternatives like get_site_details or list_sites. The usage context is implied but lacks explicit guidance 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 bears full burden. It discloses the return fields (current, latest, deprecated), but does not mention any side effects, rate limits, or authentication needs. It is minimally adequate.

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

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

The description is short and front-loaded with purpose, but includes an unnecessary and incorrect parameter line. Every sentence should earn its place; this one does not.

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 output schema exists, the description's mention of return fields is helpful. However, the incorrect parameter mention and lack of usage guidance make it incomplete for a fully informative tool description.

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, but the description includes an 'Args: settings: Application settings' line, which is misleading and contradicts the schema. This reduces the value added for parameter understanding.

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

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

The description clearly states the tool retrieves API version control information, which is a specific verb-resource combination. It distinguishes itself from sibling tools that focus on performance, connectors, integration, etc.

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, or any prerequisites. The description merely states what it does without context for selection.

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

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

No annotations are provided, so the description carries full burden. It states the tool returns status information but does not explicitly disclose that it is a read-only, non-destructive operation. For an AI agent, explicit safety guarantees are missing.

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. Every word serves a purpose, making it easy to parse quickly with no redundancy.

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

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

The description is adequate for a simple health check with no parameters and an output schema. It covers the purpose and return value, though it could mention typical use cases like monitoring or startup verification.

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 description does not need to add parameter semantics. Schema coverage is 100%, meeting the baseline for zero parameters.

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 is for a health check to verify the server is running, using a specific verb and resource. It is distinct from all sibling tools which are focused on network, connector, and integration operations.

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

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

The description implies usage when needing to verify server status, but does not explicitly state when to use or not use it, nor does it mention any alternatives. Given the clear purpose and lack of similar tools, implied usage is acceptable but not explicit.

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

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

The description indicates a read operation with no side effects. While no annotations exist, the description is sufficient for a simple list tool. The mention of 'aggregated stats' gives useful context beyond the tool name.

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 description is short. However, the 'Args' and 'Returns' lines are unnecessary for a tool with no parameters and an existing output schema, adding minor clutter.

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

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

While the output schema exists, the description does not explain what 'aggregated stats' means or any limitations. The misleading parameter documentation also reduces completeness. Adequate but with gaps.

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

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

The description includes 'Args: settings: Application settings' but the input schema has no parameters. This is a clear contradiction that misleads the agent, despite 100% schema coverage and zero parameters.

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 lists all sites with aggregated stats, using a specific verb ('list') and resource ('all sites'). It distinguishes from sibling tools like list_sites which likely lacks aggregated stats.

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

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

No explicit guidance on when to use this tool versus alternatives like list_sites or get_site_details. The description implies it's for an overview with aggregated stats, but does not provide when-not-to-use or direct 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 provided; description carries burden. It mentions pagination and that it returns categories. However, it does not discuss permission requirements, error scenarios, or behavior when parameters are 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?

Very efficient: three short paragraphs with clear structure. Front-loaded summary, then context, then parameters. No unnecessary words.

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

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

Given the presence of an output schema, description adequately covers purpose, scope, parameters, and pagination. Missing details like authentication or rate limits, but simple enough 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?

Adds meanings beyond the schema: limit range (1-1000), offset as skip count. Schema only defines types and nullability, so description adds 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 clearly states it lists DPI application categories and specifies it is global. However, it does not explicitly differentiate itself from sibling tools like list_integration_* tools, though the name and context are sufficient.

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 context that it is global and not site-scoped, implying when it should be used (for global DPI categories). No explicit when-not-to-use or alternative tools mentioned.

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

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

No annotations are provided, and the description only repeats pagination details from the schema. It does not disclose any behavioral traits, such as performance implications, authorization requirements, or whether the result is sorted. The mention of a nonexistent 'settings' parameter further harms transparency.

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

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

The description is relatively short but includes an unnecessary and incorrect 'settings' line. The structure is clear with labeled sections but could be more focused.

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

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

While the output schema exists, the description lacks context about the scope of 'all managed hosts', any filtering, or how it differs from similar tools. With no annotations, the description does not sufficiently compensate for missing behavioral or contextual information.

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

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

The description explains 'limit' and 'offset' for pagination, adding meaning beyond the raw schema. However, it also lists a 'settings' argument that does not exist in the input schema, which misleads the agent about available parameters.

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 all managed hosts/consoles,' clearly indicating a list operation. However, it incorrectly mentions a 'settings' parameter that is absent from the input schema, causing 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 on when to use this tool versus alternatives like 'get_host' or 'search_across_sites'. No discussion of prerequisites or limitations.

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 exist, so the description must disclose behavior. It mentions pagination and a limit range (1-1000), but does not cover ordering, defaults for missing parameters, or authentication requirements. The description adds some value but is incomplete.

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 uses a docstring structure with Args and Returns, which is clear. However, it includes an erroneous parameter and could be more front-loaded. The length is appropriate but not 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?

For a list tool with pagination, the description is fairly complete, noting it returns a paginated list. However, it omits prerequisites like authentication and does not specify the ordering of results. The output schema may cover return values, but overall completeness is average.

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 0% schema coverage, the description should compensate. It adds a range for limit (1-1000) and describes site_id, but incorrectly includes a non-existent parameter 'settings', which contradicts the schema. This error significantly reduces reliability.

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

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

The description clearly states 'List connected clients via the integration API,' using a specific verb and resource. It distinguishes from siblings by specifying 'clients' among many list_integration_* tools, though it doesn't explicitly differentiate from get_integration_client.

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

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

No guidance is provided on when to use this tool versus alternatives like get_integration_client or other list_integration_* tools. The description lacks context for appropriate usage.

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

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

No annotations provided, so description must disclose behavior. Mentions 'List' (read-only) and 'Returns paginated list' but does not address auth requirements, rate limits, or side effects. Minimal 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?

Docstring format with Args and Returns is clear and front-loaded. However, includes an incorrect parameter ('settings'), reducing conciseness. Reasonably structured but flawed.

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 (paginated list) so description need not detail returns, but it does mention pagination. Missing explanation of 'adopted devices' and does not cover all parameters correctly. The erroneous parameter hurts 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?

Description lists 'settings' parameter which is not present in the input schema. This contradicts the schema and adds confusion. Schema coverage is 0%, so description should clarify parameters, but it introduces an error.

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

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

Clearly states the action (List), resource (adopted devices), and context (via integration API). Distinguishes from siblings like list_integration_clients and list_integration_networks.

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?

Implied usage: to list devices. No explicit guidance on when to use vs alternatives (e.g., get_integration_device for a single device) or when not to use. Lacks exclusion criteria.

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

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

With no annotations, the description must disclose behavior. It indicates a read-only operation ('List') and mentions pagination via limit and offset. However, it includes a phantom parameter 'settings' not in the schema, which could confuse an AI agent. It does not describe auth requirements, rate limits, or error handling.

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 brief opening sentence followed by a structured list of parameters and return type. It avoids unnecessary words. The only minor issue is the extraneous 'settings' parameter, but overall structure is clear.

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

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

For a list tool with an output schema, the explanation of input parameters and pagination provides adequate context. However, it lacks usage guidance, error conditions, or prerequisites. The presence of a phantom parameter reduces completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to site_id, limit, and offset, including range for limit. However, it also lists 'settings' which is not present in the schema, causing inconsistency. The parameter descriptions are otherwise helpful but not comprehensive.

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

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

The description clearly states the action (list) and resource (device tags) via the integration API. It distinguishes from sibling list_* tools by specifying 'device tags' as the target. Could be improved by noting the scope or return structure, but it is sufficient.

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. The sibling list_* tools serve different resources, but the description does not clarify the context or prerequisites for using this specific 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 no annotations, the description carries full burden but only states it lists policies, without disclosing idempotency, permissions, rate limits, or pagination behavior beyond a generic 'Paginated list'. Minimal transparency.

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

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

The description is concise and includes structured Args/Returns, but the erroneous 'settings' parameter reduces accuracy. Otherwise 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 an output schema exists, the description suffices for a simple list operation. It implies site-scoped listing via site_id and pagination. Lacks deeper explanation but is adequate.

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

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

Schema coverage is 0%, but description adds ranges for limit (1-1000). However, it incorrectly mentions a 'settings' parameter not in the schema, causing confusion. Offset info is basic.

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

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

The description clearly states 'List DNS policies via the integration API', using a specific verb and resource. Among siblings, it distinguishes from 'get_integration_dns_policy' by indicating bulk 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?

The description provides no explicit guidance on when to use this tool versus alternatives like 'get_integration_dns_policy'. It does not mention context, prerequisites, 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?

No annotations are provided, so the description carries full burden. It mentions 'List' implying read-only, and pagination via limit/offset, but lacks explicit statements about side effects, authentication requirements, or error behaviors.

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 uses a docstring format with separate sections, which is structured but slightly verbose. It contains a brief one-liner and then bulleted args/returns, which is acceptable but not extremely 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?

Despite having an output schema (not shown), the description only says 'Paginated list of integration API networks' without detailing the return fields. It also omits error conditions, making it incomplete for an agent to fully understand the tool's behavior.

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

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

Schema description coverage is 0%, so description must compensate. The Args section adds meaning for site_id, limit, and offset, but also lists a 'settings' parameter not present in the schema, causing confusion. The explanations are minimal and one is incorrect.

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

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

The description clearly states 'List networks via the integration API', specifying the verb (list), resource (networks), and API scope (integration API). It distinguishes itself from sibling list tools like list_integration_clients or list_integration_devices.

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 connector_network_get (which might retrieve a single network) or other list tools. The description lacks usage context 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?

Despite no annotations, the description discloses pagination and return type. However, it omits details on permissions, rate limits, side effects, or handling of large result sets.

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 reasonably concise and structured with bullet-like lists, but the inclusion of a non-existent 'settings' parameter reduces clarity.

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 presence of an output schema, the description adequately notes paginated results. However, it lacks details on filtering or pagination metadata, which would improve completeness.

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

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

The description adds meaning for 'limit' (max 1-1000) and 'offset' (skip count), but incorrectly includes 'settings' in Args which is not in the input schema, causing confusion.

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

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

The description clearly states it lists sites via the integration API and returns UUID-based identifiers, which differentiates it from regular site listing tools. However, it could be more explicit about how it differs from sibling tools like list_sites.

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 context by mentioning suitability for other integration API tools, but lacks explicit when-to-use or when-not-to-use guidance, and does not exclude 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 full burden. It only states the purpose and lists parameters, but lacks disclosure of behavioral traits such as pagination specifics, authentication requirements, or potential side effects. The mention of 'paginated list' 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 description uses a structured docstring format with Args and Returns sections. It is relatively concise but includes an extraneous parameter (settings) that does not exist in the schema, reducing clarity.

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

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

Given the tool's simplicity and presence of an output schema, the description is minimal. It fails to explain pagination behavior, the purpose of the site_id, or any constraints beyond the parameter list. The missing settings parameter further undermines 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 description adds some value for limit and offset (constraint 1-1000, skip purpose) which schema lacks, but includes a phantom 'settings' parameter not in the schema, creating confusion. Schema coverage is 0%, so description should compensate but instead introduces an error.

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 lists VPN servers via the integration API, with a specific verb and resource. However, it does not explicitly distinguish from sibling list tools like list_integration_clients or list_integration_devices, though the resource name is unique.

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. No exclusions, prerequisites, or context about when to prefer this over other list or VPN-related tools.

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

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

No annotations provided. The description only says 'Returns: Paginated list of WAN connections' but does not disclose authentication needs, rate limits, error behavior, or consequences of invalid parameters.

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 structured as a docstring with Args/Returns sections, but includes an extraneous 'settings' parameter. It is moderately concise but could be tighter.

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 output schema exists, the description covers basic parameters and return type. However, it lacks pagination behavior details, error handling, and usage context. It is adequate but not 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 description provides constraints for 'limit' (1-1000) and explains 'site_id' and 'offset', which adds value over the schema (which has 0% description coverage). However, it mentions an extra 'settings' parameter not present in the input schema, causing inconsistency.

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

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

The description clearly states 'List WAN connections' which is a specific verb and resource. It also mentions pagination via limit/offset, but does not differentiate from siblings like list_integration_networks or list_integration_devices.

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

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

No explicit guidance on when to use this tool versus alternatives. No prerequisites, context, or exclusions mentioned. The description only explains parameters.

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

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

No annotations are provided, so the description must fully convey behavioral traits. It states a 'paginated list' is returned, which is helpful, but fails to disclose whether the operation is read-only, any authentication needs, or potential rate limits. The phantom 'settings' parameter undermines reliability.

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 structured with an Args section and Returns, but it includes redundant phrasing ('via the integration API') and an extra line for the phantom 'settings' parameter. Could be more concise without sacrificing accuracy.

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 an output schema exists, the description does not need to detail return values extensively, but it does mention 'paginated list'. Missing is a comparison with the singular get endpoint or any prerequisite context. Overall adequate but not 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 0%, so the description must explain all parameters. It does describe the three schema parameters (site_id, limit, offset) adequately, but erroneously includes a 'settings' parameter not present in the schema, confusing the agent.

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

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

The description clearly states the action (List) and resource (WiFi broadcasts/SSIDs). It implicitly distinguishes from the sibling tool 'get_integration_wifi_broadcast' by using 'list' vs 'get'. However, the inclusion of a non-existent parameter 'settings' slightly diminishes clarity.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like 'get_integration_wifi_broadcast'. It only implies the usage through the name and parameter descriptions, but no when-to-use or when-not-to-use context is 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?

No annotations are provided, so the description must cover behavioral traits. It only states 'List all SD-WAN configurations' without disclosing pagination, permissions, rate limits, or any side effects. The read-only nature is implied but not explicit.

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, but it includes an inaccurate 'Args' section that takes space without value. It is not efficiently structured; front-loading would be 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?

Given that the tool has an output schema and no parameters, the description could be minimal. However, it fails to explain the scope of 'all' configurations, any sorting or filtering, or how the output relates to other tools. The mention of a non-existent parameter further reduces 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 input schema has zero properties, but the description introduces a non-existent parameter 'settings: Application settings'. This directly contradicts the schema and misleads about required inputs, earning a low score.

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

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

The description states 'List all SD-WAN configurations,' which clearly indicates a list operation on SD-WAN configs. However, it includes an 'Args' section mentioning 'settings' that does not exist in the input schema, causing confusion. Siblings like get_sdwan_config imply singular retrieval, but the description does not explicitly differentiate.

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 like get_sdwan_config or get_sdwan_config_status. There is no mention of prerequisites, filters, or context for selection.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states that it returns a list of site dictionaries, but does not mention side effects, access control, rate limits, or pagination behavior. The agent is left uninformed about operational 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, using a clear docstring format with Args and Returns sections. It avoids unnecessary verbosity, though the Args section is minimal and could be more 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?

Given that an output schema exists, the description does not need to detail return values, but it still does. However, it lacks information on authentication, pagination defaults, and what qualifies as 'accessible'. It is adequate but not comprehensive.

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

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

The schema has 0% description coverage, so the description must compensate. It merely restates parameter names (limit, offset) without explaining their semantics, defaults, or effects. For example, it does not clarify that limit controls the maximum number of results or how offset works.

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

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

The description clearly states 'List all accessible sites.' which specifies the verb and resource. However, it does not differentiate it from sibling tools like list_all_sites_aggregated, which might offer similar functionality with aggregation.

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. The description lacks context about prerequisites, scenarios, or comparisons with sibling tools.

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

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

No annotations are available, so the description holds the full burden. It only says 'List all Vantage Points' without disclosing any behavioral traits such as ordering, pagination, or side effects. There is no mention of read-only nature or data freshness.

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 but contains inaccurate information (fictitious 'settings' parameter). It is not concise in a helpful way, as every sentence should be correct.

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 annotations, an empty input schema, and an output schema available, the description is insufficient. It fails to explain what a Vantage Point is, how to use the tool, or any prerequisites.

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

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

The input schema has zero parameters, giving a baseline of 4. However, the description incorrectly lists an 'settings: Application settings' argument, contradicting the schema. This misleading information worsens the score.

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

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

The description clearly states 'List all Vantage Points' with a specific verb and resource, making the tool's purpose unambiguous. Despite many sibling list tools, the resource is distinct.

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

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

No guidance is provided on when to use this tool versus alternatives like other list tools (e.g., list_hosts, list_sites). The description does not mention context 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 only states it returns a list of metrics, but does not disclose safety profile, authentication needs, rate limits, or mutation behavior. This 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 description is concise with a summary line and structured Args/Returns format. However, the inclusion of an extra parameter ('settings') not in the schema is a clarity issue.

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

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

With no annotations and 0% schema coverage, the description is insufficient. It lacks information on pagination, filtering behavior, error handling, and completeness of the return values. Output schema exists but description still needs more behavioral 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?

Schema coverage is 0%, so description must compensate. It describes three schema parameters (site_id, start_time, end_time) with format hints, but also includes 'settings' which is not in the schema, causing inconsistency. It adds some meaning, but inaccuracy reduces score.

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

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

The description clearly states the tool queries ISP metrics with optional filters. The verb 'query' is specific. However, it does not distinguish from sibling tool 'get_isp_metrics', which likely performs a similar function.

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

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

The description implies usage by mentioning optional filters but provides no explicit guidance on when to use this tool versus alternatives like 'get_isp_metrics' 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?

No annotations are provided, so the description carries full burden. It discloses that search is across all sites and returns site context, but lacks details on performance, pagination, or any non-obvious behaviors (e.g., rate limits). Transparency is adequate but not comprehensive.

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 a clear structure: brief intro, search scope, use case, and explicitly labeled Args/Returns sections. Every sentence is purposeful and no unnecessary words.

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

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

Given the tool's moderate complexity (2 params, output schema exists), the description covers the search scope, query types, and site context in returns. It does not elaborate on output schema but that is acceptable since an output schema is present. Minor gap: no mention of result count or limitations.

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 0%, so the description must compensate. It fully explains both parameters: 'query' (supported formats) and 'search_type' (valid values with default). This adds crucial semantic meaning beyond the schema's type-only definitions.

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

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

The description clearly states the tool's purpose: searching for resources (devices, clients, networks) across all managed sites. It specifies the resource types and highlights usefulness in multi-site deployments, distinguishing it from single-site or inventory tools among siblings.

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

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

The description provides context ('useful for locating resources in multi-site deployments') but does not explicitly state when not to use this tool or mention alternatives. Clear guidance is given on the scope, but exclusions are absent.

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