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

With no annotations, the description carries the full behavioral burden. It accurately signals a read-only retrieval via 'Get', but it doesn't disclose the shape of the returned detail, error behavior, or permissions. This is acceptable for a simple get-by-ID yet leaves specifics to inference.

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

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

One short sentence with no filler; the key information (action, resource, identifier) is front-loaded and immediately parseable.

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 low-complexity, one-parameter get-by-ID tool, the description and schema are nearly sufficient to invoke it correctly. Lacking an output schema, it would benefit from a hint about the response format, but the missing information is minor.

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

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

The single parameter is fully documented in the schema, and the ID description adds provenance ('from uisp_list_data_links') beyond the raw type. This tells the agent where to obtain a valid value, improving call correctness.

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

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

The description uses a specific verb ('Get') and resource ('single data link's detail') plus the selection mechanism (`by ID`). It clearly identifies the operation, and the 'single' qualifier separates it from list-style siblings, though it doesn't name them.

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

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

No explicit guidance explains when to call this tool instead of uisp_list_data_links or uisp_list_site_data_links. The only contextual clue is in the parameter schema ('from uisp_list_data_links'), which implies an ordering but doesn't state selection criteria.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It conveys a read operation and a 'status overview' but does not mention what fields are included, how errors are handled if the ID is invalid, or any authentication or rate-limit considerations.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. It communicates the operation, the scope, and the identifier type efficiently.

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

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

For a simple single-ID getter, the description is minimally sufficient, but with no output schema and no annotations, the agent is left without information about the return shape or failure behavior. The tool is straightforward enough that this is a gap rather than a fatal flaw.

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

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

The schema has 100% coverage for the single required parameter, including a helpful provenance note ('from uisp_list_devices'). The description adds only the phrase 'by ID,' which does not materially enrich what the schema already states, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Get'), a clear resource ('a single device's status overview'), and the lookup key ('by ID'). It distinguishes itself from list-style siblings and from get_device_detail through the 'status overview' scope, though it does not explicitly name the difference.

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

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

No guidance is given on when to use this tool versus alternatives such as uisp_get_device_detail, uisp_get_device_statistics, or uisp_get_device_by_mac. The intended context is only implied by the phrase 'status overview,' with no explicit exclusions or sibling comparisons.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. 'Look up' signals a read-only, non-destructive operation, which is the key behavioral trait for this tool. However, it does not mention what is returned, how missing devices are handled, or whether special permissions are needed.

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

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

The description is a single direct sentence with no filler or redundancy. It is front-loaded and appropriately sized for a tool with one required parameter.

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

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

For a simple single-parameter lookup, the description is minimally viable. However, with no annotations and no output schema, it would benefit from clarifying what the tool returns and how it differs from uisp_get_device when selecting the appropriate tool.

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

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

Schema description coverage is 100%, and the schema already documents the mac parameter with an example. The description only restates that this is a MAC-address lookup and adds no additional syntax, formatting, or edge-case semantics beyond the schema.

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

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

The description states a specific verb ('look up'), a resource ('device'), and the exact lookup key ('by its MAC address'). This distinguishes it from sibling tools like uisp_get_device or uisp_get_device_detail, which are likely keyed on other identifiers.

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 for when to use this tool versus sibling alternatives such as uisp_get_device or uisp_list_devices. The MAC-address qualifier gives some implicit context, but there are no explicit conditions, exclusions, or alternative tool recommendations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the tool is read-only, what the response contains, how interfaces are included, or why the schema only exposes withStations despite the description mentioning interfaces.

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 one efficient sentence that leads with the core action and resource. It is not bloated, though the unsupported 'interfaces' clause slightly reduces precision.

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

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

With no output schema and no annotations, the description should explain what 'detail' includes and how the optional parameters affect the result. It does not, and the interface/stations ambiguity leaves an agent uncertain about the tool's actual return shape and default behavior.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds little beyond restating the withStations parameter's purpose and introduces an 'interfaces' concept not represented in the schema, so it does not meaningfully improve parameter understanding.

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

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

The description clearly identifies the action ('Get') and the resource ('a single device's detail'), which distinguishes it from list-style tools. However, it does not differentiate from the closely named sibling uisp_get_device, and the mention of 'interfaces' is not backed by a schema parameter, introducing slight ambiguity.

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

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

No guidance is given on when to use this tool versus alternatives like uisp_get_device or uisp_list_device_interfaces. The optional inclusion of stations/interfaces implies a use case, but there is no explicit when-or-when-not guidance.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It conveys a read-only telemetry operation and bucket granularity, but does not explain aggregation semantics (e.g., averages vs. raw samples), units, data availability windows, or edge-case behavior. This is a thin disclosure beyond the obvious 'Get' semantics.

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

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

A single, efficient sentence that front-loads the action and resource, with the metric list parenthetically. No filler or redundant content.

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

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

The parameters are well documented and enough to construct a valid call, but with no output schema the description leaves the response contract unclear: units, aggregation method, time range, and result shape for the bucketed telemetry are unspecified. For a statistics endpoint, this is a moderate completeness gap.

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

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

Schema coverage is 100%, with the id and interval parameters already described in the input schema. The description adds context about telemetry categories but does not meaningfully extend parameter semantics beyond what the schema provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get'), identifies the resource ('device telemetry'), enumerates the metric categories (CPU/RAM/signal/temperature/throughput), and notes interval bucketing. This clearly distinguishes it from sibling tools like site/network statistics or device detail endpoints, even without naming them.

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

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

The description implies usage for per-device telemetry with time bucketing, but it never states when to choose this over alternatives such as uisp_get_site_statistics or uisp_get_network_statistics. No exclusions or selection criteria are provided.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the operation ('Get') and does not disclose what 'detail' includes, error behavior, authentication requirements, or whether the operation is read-only. The agent is left without information beyond the tool's purpose.

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

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

One short sentence that is front-loaded with the action and resource. No empty words or redundancy. It effectively communicates the core purpose in the minimal space needed.

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

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

The tool is a simple get-by-ID with a single well-described parameter, so the description plus schema might be sufficient for calling it. However, there is no output schema, and the description's vague 'detail' does not tell the agent what fields to expect in the response. This is a notable gap given the absence of structured output metadata.

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

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

Schema coverage is 100%, as the single parameter 'id' includes a description indicating the ID comes from uisp_list_gateways. The description adds no additional parameter meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb 'Get', a specific resource 'gateway's detail', and the selection mechanism 'by ID'. This clearly distinguishes it from sibling list/search tools like uisp_list_gateways and uisp_search_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 does not explicitly state when to use this tool versus alternatives. However, the parameter schema hints at the intended workflow with 'Gateway ID (from uisp_list_gateways)', implying the tool should be used after listing gateways. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full behavioral burden; 'Get' and the listed statistics signal a non-mutating read, which is important. However, it does not mention aggregation semantics, the exact scope of 'network' (all sites vs managed network), or any limitations such as data retention or latency. The description is not misleading, but it discloses only basic read 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?

Single sentence with an inline list; the verb and resource are front-loaded. Every listed item earns its place with concrete domain terms, and there is no filler or duplication of schema content.

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

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

For a simple read-only statistics call with two parameters and no output schema, the description tells the agent what it will receive (the aggregate categories), and the schema covers invocation details. It is slightly under-specified only in the overlap with the ambiguous uisp_get_summary sibling, but the listed contents are sufficient 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 covers both parameters with descriptions (100% coverage), including the interval enum values and the siri default of false. The tool description adds no further parameter-level detail beyond naming the statistics themselves. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description opens with 'Get network-wide statistics' — a specific verb and resource whose scope is explicitly network-wide, setting it apart from sibling stats tools like uisp_get_site_statistics and uisp_get_device_statistics. The colon-list enumerates concrete return categories (client/site counts, health, scores, utilization, outages). It doesn't explicitly name a sibling, but 'network-wide' is sufficient directional differentiation.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no sibling alternatives are named. Use case is implied by the resource name and the phrase 'network-wide', but an agent gets no help deciding between this tool and uisp_get_summary or the per-site statistics tool. That makes the guidance implied rather than 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?

With no annotations, the description carries the burden of behavioral disclosure and does state that the response includes status and, conditionally, a UCRM reference. However, it does not describe behavior for invalid or missing IDs, the read-only nature explicitly, or how the optional ucrmDetails flag changes the returned structure.

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

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

A single, front-loaded sentence with no filler. It conveys the operation, resource granularity, and the notable returned data efficiently without repeating the tool name or schema verbatim.

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

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

For a simple two-parameter GET tool with no output schema, the description covers the primary purpose and key return fields. It is slightly incomplete because it does not specify the default behavior of ucrmDetails or the response when the site ID is not found, but these are minor for a basic single-record retrieval.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description adds mild value by clarifying that status is part of the detail and that the UCRM reference appears only when linked, but it does not substantially go beyond the schema 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 uses a specific verb ('Get') and a specific resource ('a single site's detail'), and names key returned content (status and UCRM client/service reference). It is clearly distinct from list-style siblings, though it does not explicitly contrast with tools like uisp_get_site_statistics or uisp_get_site_traffic_summary.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance relative to sibling tools such as uisp_list_sites or uisp_get_site_statistics. The phrase 'single site' implies retrieving one specific record, but alternatives, prerequisites, and exclusion conditions are left to inference. The schema's note that the id comes from uisp_list_sites is helpful but not part of the description itself.

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

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

With no annotations, the description must carry the behavioral burden. It discloses that the tool retrieves upload/download traffic in buckets and that it is a read-style operation, but it does not describe response contents, units, or any limitations such as time ranges. This is adequate but not rich.

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

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

A single sentence that front-loads the action and the key constraints (parent site, interval bucketing). Every word earns its place; there is no 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?

For a simple two-parameter read, this is close to complete, but the lack of an output schema and annotations means the description should say more about return units or response shape. It also does not disambiguate against the sibling summary tool, leaving some selection ambiguity.

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

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

The schema already fully documents both parameters, but the description adds value by clarifying that siteId denotes the site whose traffic to its parent site is being measured. The interval bucketing is also implicitly tied to the interval parameter, slightly enriching the schema.

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

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

The description uses a specific verb and resource ('Get upload/download traffic between a site and its parent site') and states the key detail of interval bucketing. It is clear, but it does not explicitly differentiate itself from the closely named sibling uisp_get_site_traffic_summary.

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 makes it clear when this tool is relevant (when interval-bucketed traffic between a site and its parent is needed), but it provides no explicit guidance on when to choose it over uisp_get_site_traffic_summary or other statistics tools. Usage is implied by the purpose rather than stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the result is current interval-to-date upload/download totals, which is useful, but it does not describe units, return shape, timezone handling, or how 'now' is determined. The description is reasonably transparent for a simple read operation but leaves room for ambiguity.

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

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

The description is a single focused sentence with no filler. It front-loads the action and resource, then appends the interval constraint. Every word contributes to understanding the tool's purpose.

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

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

For a simple two-parameter tool, the description gives a fair overall picture, but there is no output schema and no mention of units, exact return format, or whether the totals are cumulative for the current interval. Given the sibling tools and lack of annotations, an agent would benefit from more explicit return-value 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 100%, so the input schema already explains both parameters. The description adds 'total upload/download' context and 'up to now' meaning for the interval, but it does not add meaningful details beyond the schema's field descriptions and enum values.

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

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

The description clearly states an action ('Get'), a resource ('a site's total upload/download'), and a scoping condition ('for the given interval up to now'). It is specific enough about what the tool does, though it does not explicitly differentiate it from similar sibling tools like uisp_get_site_statistics.

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

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

There is no guidance about when to use this tool versus alternatives such as uisp_get_site_statistics, uisp_get_summary, or uisp_get_network_statistics. The phrase 'up to now' implies current-interval behavior, but no explicit when-to-use or when-not-to-use information is provided.

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

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

With no annotations, the description must carry the behavioral disclosure burden. 'Get detail' implies a read operation and 'running and recent' signals scope, but the description does not state whether results include historical data, whether it is purely read-only, or what a response contains.

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

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

A single nine-word sentence with no filler. The key qualifiers ('running', 'recent') are front-loaded and every word contributes to the meaning.

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

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

For a parameterless getter, the description conveys enough to select it: the resource is speed tests and the scope is running/recent. It could be more complete by hinting at the returned data shape, but the low complexity and absence of parameters reduce the need.

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

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

The tool has zero parameters and the schema covers 100% of them, so the baseline is 4. The description does not need to add parameter details and does not attempt to.

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

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

The description names a concrete resource (speed tests) and a verb (get detail), and the 'running and recent' qualifier narrows the scope. It is clear enough to distinguish this from the sibling site/device/network tools, though 'get detail' is less precise than an action like 'list' or 'return results.'

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

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

There is no explicit guidance on when to use this tool or when to prefer a sibling. The phrase 'running and recent' implies a temporal filter, but no use cases, exclusions, or alternatives are mentioned.

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

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

With no annotations, the description carries the behavioral burden. It adds helpful semantics: counts are badge-like, timestamps filter to newer items, and 0 returns current totals. It also clarifies the tool is a read-only aggregate by describing retrieval of counts, not mutations.

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

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

Two dense sentences with no filler; the main purpose is front-loaded. The long internal list of counts is necessary context and is ordered logically. It could be slightly easier to parse, but every clause earns its place.

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

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

Despite lacking an output schema and annotations, the description names the key return categories and explains timestamp semantics, including the 0 default behavior. It is adequate for an agent to understand what this summary tool returns and how to scope it.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema by introducing the 'pass 0 for current totals' convention and tying the timestamps to named unread-count outputs, making the optional timestamp behavior more actionable.

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

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

Names a specific verb and resource: 'Get badge-count-like values across the instance.' It enumerates the exact output categories (unread logs/outages/firmwares, client/site counts, devices needing authorization) and clearly differs from sibling list/get tools that operate on individual resources.

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

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

The description implies use for instance-wide summary counts rather than detailed per-resource data, and it explains timestamp scoping. However, it never explicitly says when to choose this tool over list_sites, list_logs, or list_outages, nor does it name alternatives or exclusion conditions.

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

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

With no annotations provided, the description carries the full behavioral burden; 'Get' signals a read-only operation and 'currently' signals a point-in-time snapshot. However, it does not disclose scope, authentication expectations, or failure behavior, leaving a moderate transparency gap.

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

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

The description is a single front-loaded sentence with no filler or redundant restatement. Every word earns its place: 'number' clarifies the return type and 'currently in progress' defines the filter.

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

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

For a zero-parameter, read-only count tool, the description is largely complete: it states the operation, the object, and the return type. It would be stronger if it clarified the scope of 'tasks' (global vs. site-specific), but the absence of a site parameter makes the global interpretation reasonable.

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, so the description has no parameter-documentation burden; the baseline of 4 applies. The description correctly avoids inventing parameters the schema does not define.

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

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

The description states a specific verb ('Get'), resource ('tasks'), and output type ('number ... currently in progress'), making the function immediately clear. It does not explicitly contrast with sibling uisp_list_tasks, but the count-vs-list distinction is apparent from the wording.

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

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

The phrasing implies the tool is appropriate when a count of in-progress tasks is needed rather than a detailed task list, but no explicit when-to-use or when-not-to-use guidance is provided. Sibling tools such as uisp_list_tasks are not mentioned, so the agent must infer the distinction.

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

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

With no annotations, the description carries the behavioral burden. It communicates that this is a read-style operation ('Get') and specifies the returned categories (version, deployment type, build info), plus the diagnostic use case. It stops short of stating error behavior or explicitly confirming no side effects, but these are low risk for a version query.

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

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

The description is a single, front-loaded sentence. Every clause adds information: what is returned and why you would call it. There is no padding or repetition.

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

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

For a zero-parameter endpoint with no output schema, the description adequately covers return values and purpose. It could mention exact field names or potential failure modes, but the tool is simple enough that an agent can select and invoke it confidently.

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

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

The tool has zero parameters, so the schema fully covers parameter semantics by default. The baseline of 4 applies, and the description appropriately adds no redundant parameter detail.

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

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

The description names a specific verb and resource ('Get the UISP version') and adds the exact data returned: deployment type and build info. This distinguishes it from all sibling tools, none of which target version information.

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

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

The phrase 'Useful as a credential/connectivity sanity check' gives a clear context for when to invoke the tool. It does not explicitly name alternatives or exclusions, but for a version endpoint no competing sibling is apparent.

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

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

With no annotations, the description carries the full burden, and it adds useful behavioral context beyond the tool name: it explains the link types (wireless/wired), scope (devices and sites), and the included detail fields (signal/frequency/distance). This makes the read-only listing behavior and returned content reasonably transparent, though pagination or output shape are not addressed.

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

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

The description is a single focused sentence that front-loads the action and resource, then packs in the most useful qualifiers (wireless/wired, devices/sites, signal/frequency/distance) without redundancy.

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

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

For a simple list tool with one optional boolean parameter, the description plus schema covers the essential invocation context. It identifies what is returned and at what granularity. The only gaps are minor: no mention of pagination, authentication needs, or how this differs from the site-only sibling tool.

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

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

Schema coverage is 100% and the only parameter, siteLinksOnly, already has a clear description. The tool description doesn't add parameter-level details, but it does give helpful background on what a 'data link' is, so the baseline 3 is appropriate.

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

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

The description uses a specific verb ('List') and identifies the resource ('data links') with meaningful elaboration: the links are wireless/wired and include signal/frequency/distance detail. It is clear what the tool does, though it doesn't explicitly distinguish itself from the closely related sibling uisp_list_site_data_links.

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

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

The description implies the tool is for retrieving mapped links between devices and sites, which gives the agent a reasonable sense of when to use it. However, it provides no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as uisp_list_site_data_links or uisp_get_data_link.

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?

There are no annotations, so the description carries the behavioral burden. 'List' implies a read-only operation, and the description discloses what data is included. However, it does not mention whether all interfaces are returned, how failures with invalid device IDs behave, or any additional behavioral constraints.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then adds the key return-value detail. There is no redundant or filler wording.

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

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

For a simple one-parameter list operation, the description is nearly complete: it states the resource and what is included in the result. The lack of an output schema is partially compensated by naming the returned content. Minor gaps like return shape for empty results or error behavior keep it from a perfect score.

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

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

The schema already fully documents the single parameter with 100% coverage: 'Device ID (from uisp_list_devices).' The description adds little beyond 'device's interfaces,' which is sufficient given the schema's completeness, but it does not independently enrich parameter meaning.

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

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

The description names a specific verb ('List'), a specific resource ('a device's network interfaces'), and the key data returned ('configured IP addresses and status'). This clearly separates it from the many device-related sibling tools, such as uisp_get_device or uisp_list_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?

The tool's purpose is clear enough that an agent can infer it should be used when interface-level detail is needed for a device. However, the description gives no explicit guidance about when to prefer it over alternatives like uisp_get_device_detail or uisp_get_device, nor any 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?

No annotations are provided, so the description carries the behavioral burden. It discloses the returned device attributes and the chaining behavior, and 'List' implies a read-only operation. However, it does not mention pagination, response shape, or the behavior of the withInterfaces option, which can significantly change the response.

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

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

The description is two sentences with no filler. The first sentence front-loads the core purpose and filters, and the second provides valuable downstream workflow context by connecting to related tools.

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 filterable list tool with no annotations and no output schema, the description gives enough to call it correctly: what it returns and how the results chain into later tools. It is slightly incomplete in not addressing pagination or the withInterfaces effect, but the schema and simple list semantics keep it 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 description coverage is 100%, so the schema already documents all five parameters. The description adds little beyond naming site/type/role/authorization filters and omits withInterfaces, but the schema fills that gap adequately.

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

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

The description uses a specific verb and resource ('List devices') and states the returned fields (hostname/IP/MAC, status, parent site). It also clarifies that it is the entry point for later device-level lookups by chaining the device 'id' into related tools, which distinguishes it from get_device and list_discovered_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?

The usage context is implied: this is for enumerating devices, optionally filtered, and for obtaining device IDs to use in related device tools. However, it does not explicitly say when to prefer this over alternatives such as uisp_get_device_by_mac or uisp_list_discovered_devices.

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

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

No annotations are present, so the description carries the burden of indicating the operation is a read-only list. 'List' clearly implies no mutation, but the description does not mention pagination, response details, or any access/scope limitations. For a zero-parameter read-only tool, this is acceptable but not rich.

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

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

A single, well-structured sentence that front-loads the action and key distinction, with no filler or repetition.

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

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

For a simple zero-parameter discovery list, the description is sufficiently complete: the purpose, scope, and differentiation from added devices are all clear. The lack of an output schema is not a critical gap for a list endpoint, though some return field hints could add value.

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

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

The tool takes zero parameters and schema coverage is 100%, so there are no parameter semantics for the description to clarify. Baseline 4 applies because no parameter information is needed.

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

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

The description uses the specific verb 'List' with a clear resource: devices UISP has discovered but not yet added. It distinguishes this from sibling tools like uisp_list_devices by explicitly scoping to unadded 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?

The intended use case is clear: call when you need devices discovered on the network that are not yet added. It does not explicitly point to alternatives or exclusions, but the scope is unambiguous enough for an agent to select it.

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

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

With no annotations provided, the description carries the behavioral burden. The verb 'Get' implies a read-only operation and 'firmware versions available' indicates what is returned, but there is no explicit statement about side effects, permissions, or response format. For a zero-parameter read tool this is minimally acceptable, though 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 a single, information-dense sentence with no filler or repetition of schema information. It front-loads the action and resource clearly.

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—zero parameters, no output schema, and no annotations—the description states the essential purpose without leaving critical gaps. Minor ambiguity remains about the exact return contents and its relationship to uisp_get_version, but these do not impede 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 tool has no parameters, so the baseline for this dimension is 4. The schema already shows an empty object, and there are no parameter details for the description to clarify or augment.

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

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

The description uses a specific verb ('Get') and resource ('firmware versions available to UISP for its supported device models'), making the tool's function clear. It does not explicitly contrast with sibling tools like uisp_get_version, but the 'firmware versions' wording provides a reasonable implicit distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives such as uisp_get_version or other list tools. It lacks any context about intended use cases, prerequisites, or when another tool would be more appropriate.

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

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

With no annotations, the description carries the behavioral burden. It indicates a read/list operation and the returned scope (gateways with NetFlow/QoS/suspend config), but does not mention authorization, pagination, or whether the list is system-wide or scoped to a site. Adequate but not richly transparent.

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

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

A single sentence that front-loads the verb and resource, uses a parenthetical to define gateways, and ends with a compact list of configuration categories. No filler or repetition.

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

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

For a zero-parameter list tool, the description states what is returned and which configuration areas are included. It does not describe the output shape or call out the sibling uisp_get_gateway for single-gateway needs, but those are minor gaps for such a simple tool.

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

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

The input schema has zero parameters, so schema coverage is trivially 100% and the description has no parameter semantics to add. The zero-parameter baseline of 4 applies.

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

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

Uses the specific verb 'List' with a clearly defined resource ('gateways - routers configured as network gateways') and adds concrete scope: NetFlow/QoS/suspend configuration. This distinguishes it from broader tools like uisp_list_devices and from the single-item uisp_get_gateway.

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 intended use is implied by 'List gateways' and the configuration focus, but there is no explicit guidance about when to choose this over uisp_get_gateway or uisp_list_devices, nor any exclusions. It earns a middle score for implied rather than clearly stated usage guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation ('List') but does not explicitly state read-only behavior, pagination semantics, rate limits, or any side effects. The note about MAC/IP addresses in log messages is a data-content detail, not a behavioral trait. The description is silent on response format, ordering, or limits, which is a significant gap for a tool with pagination 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 two sentences long, front-loads the primary action, and includes a concise list of filters. Every clause contributes to understanding the tool's scope. It avoids redundancy and is efficiently structured.

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

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

Given 8 parameters, no output schema, and no annotations, the description is somewhat minimal. It does not explain pagination behavior (page/count semantics are only in the schema), ordering, or the shape of the returned data. The note about MAC/IP addresses is useful but does not compensate for missing behavioral context. However, the schema covers parameter details, and the description provides a reasonable overview, making it 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?

Schema description coverage is 100% (all 8 parameters have descriptions). The description's mention of filtering by 'site, device, severity level, event tag, or a text query' maps to the parameters but adds no new meaning beyond what the schema already provides. It does not elaborate on parameter interactions, defaults, or edge cases, but the baseline of 3 applies because the schema handles the 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 lists the UISP event/audit log and provides examples of log content (logins, device state changes, backups, upgrades). It also enumerates the filtering dimensions (site, device, severity, tag, query), making the purpose specific and unambiguous. It does not explicitly distinguish from siblings like uisp_list_outages, but the resource ('event/audit log') is distinct enough that an agent can infer its 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?

The description does not mention when to use this tool versus alternatives, nor does it state any exclusions or prerequisites. It only describes what the tool does and the available filters. With no sibling differentiation or explicit usage context, an agent has no guidance on when to choose this over other log-related tools (e.g., uisp_list_tasks, uisp_list_outages).

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

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

With no annotations provided, the description carries the full burden. It clarifies that this is a list/read operation and gives domain context about outages being tied to a site and device. However, it does not disclose pagination behavior, default time ranges, ordering, or whether only current or also historical outages are returned.

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

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

A single well-structured sentence that front-loads the core operation, provides contextual framing, and enumerates key filters without waste. Every phrase earns its place.

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

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

For a 7-parameter tool with no annotations and no output schema, the description gives useful context but omits important operational details such as pagination defaults, the meaning of an optional 'period', and what fields an outage record contains. The schema covers parameter semantics, but the description leaves some gaps an agent might need when invoking the 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?

While schema coverage is 100% and the description does not add new syntax, it usefully highlights the main filter dimensions (deviceId, type, query, inProgress) and explicitly spells out the enum values 'outage/unreachable'. This adds modest value beyond the schema descriptions but leaves page, count, and period to the schema.

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

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

The description clearly states the verb 'List' and resource 'network outages', and adds meaningful context by identifying UISP's alerting surface and tying outages to a site and device. This makes it unambiguously distinct from all sibling tools, none of which target outages.

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 listing filter dimensions (device, type, text query, in-progress) and framing outages as an alerting surface, but it never explicitly states when to use this tool versus alternatives or when not to use it. There is no mention of sibling tools for broader network status, so usage guidance remains implicit.

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

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

With no annotations, the description carries the full burden. It does disclose that this is a read-only 'list' operation and adds the parent-site scoping detail. It does not mention pagination, recursion through child levels, auth requirements, or response shape, but those are less critical for a simple list tool.

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

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

One clean, front-loaded sentence with no filler. Every word earns its place and the core scoping information is immediately visible.

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 required parameter and no nested objects, the description plus schema is enough for an agent to invoke it correctly. The main gaps are the lack of explicit alternative routing and behavioral caveats, but 'list all client sites' adequately implies the return value even without an output schema.

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

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

The schema already covers the only parameter at 100% with 'Parent site ID (from uisp_list_sites).' The description restates the parent-site relationship but adds no format, source, or additional semantics beyond the schema, so the baseline 3 is appropriate.

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

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

The description uses a specific verb-resource pair, 'List all client sites belonging to a given (parent) site,' and clearly scopes the operation to a parent-child relationship. This distinguishes it from siblings like uisp_list_sites (all sites) and uisp_get_site (single site).

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

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

The use case is implied: use this when you have a parent site ID and need its client sites. However, it never explicitly says when not to use it or points to alternatives such as uisp_list_sites for listing top-level sites, so the guidance is minimal.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action and resource, without mentioning pagination, ordering, error behavior, or what the returned list contains beyond the 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 description is a single concise sentence with no filler. The key scoping phrase 'attached to a given site' is front-loaded and immediately clarifies the operation's scope.

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

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

For a one-parameter list operation, the description is adequate and the schema covers the parameter well. However, it does not address behavioral expectations or distinguish from the similar global-list sibling, leaving some implicit 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 input schema fully documents the only parameter siteId, including its source ('from uisp_list_sites'), so the baseline is 3. The description adds no additional parameter-level context beyond the schema.

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

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

The description states a specific verb ('List') and resource ('data links attached to a given site'), which clearly identifies the operation. However, it does not explicitly differentiate from the sibling tool uisp_list_data_links, which likely has a broader scope.

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

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

The description implies when to use it: whenever data links belonging to a specific site are needed. It provides no explicit alternative, exclusion, or condition to help choose between this and other list tools, such as uisp_list_data_links.

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

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

With no annotations, the description must carry the behavioral burden. It usefully clarifies that 'sites' includes endpoints and clients and that UCRM linkage is optional, but it does not mention pagination, default return behavior, or explicitly confirm read-only semantics beyond the verb 'List'.

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 compact and front-loaded, with the core action and scope in the first sentence. The second sentence earns its place by explaining how returned IDs integrate with related tools, with 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?

For a read-style list operation with fully documented parameters, the description covers the core semantics and downstream usage well. The lack of an output schema and annotations means return shape and default pagination behavior are not addressed, but this is a minor gap given the tool's simple nature.

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

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

Schema description coverage is 100%, so the six parameters are already fully documented. The description adds no parameter-level detail beyond mentioning that site IDs chain into other tools, which is consistent with the baseline score of 3.

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

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

The description clearly states the operation ('List sites') and defines the resource scope as network locations including sites, endpoints, and clients, with optional UCRM linkage. It does not explicitly distinguish itself from uisp_search_sites, so it stops short of full sibling differentiation.

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

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

The chaining sentence implies this tool is used to obtain site IDs for downstream tools like uisp_get_site and uisp_list_devices. However, there is no explicit guidance about when to use this list endpoint versus alternatives such as uisp_search_sites, leaving the usage context only implied.

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

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

The description is essentially restating that it lists tasks and their status, which is already implied by the tool name and the 'status' parameter. With no annotations provided, the description carries the full burden, but it fails to disclose key behavioral details such as whether it only returns completed tasks or includes in-progress ones, the ordering of results, or any rate limits. It also does not contradict annotations since none are present.

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

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

The description is a single, concise sentence that is front-loaded with the primary purpose. It is efficient and free of unnecessary jargon or filler, earning top marks for conciseness and structure.

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

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

Given the tool's moderate complexity (4 parameters, 2 required) and no annotations or output schema, the description is adequate but incomplete. It doesn't indicate what the response structure looks like, how pagination works, or any default behaviors. Since the parameter schema already covers parameters well, the description covers the core use but leaves gaps in operational 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 schema covers all 100% of parameters with descriptions, so the baseline is 3. The description mentions 'status' as a filter and 'background tasks' but doesn't add much beyond what the schema already says for parameters like 'period' or 'page'. It adds marginal context by listing task types, but not enough to raise 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 states the verb 'List', the resource 'background tasks', and examples of what those tasks include (firmware upgrades, backups, mass operations), making the purpose clear. However, it does not explicitly differentiate from the sibling tool uisp_get_tasks_in_progress, which could be confused as a filtered subset.

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

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

The description implies that this tool lists background tasks and provides a 'status' filter, suggesting it's used for viewing task history. However, it does not explicitly state when to use this over uisp_get_tasks_in_progress (e.g., for historical tasks versus currently running), nor does it mention any exclusions 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?

With no annotations provided, the description must carry the full behavioral burden. It doesn't disclose that the search supports geographic bias (latitude/longitude), whether results are paginated (though schema implies it), or that it returns a list of matches. No side effects or safety information is provided for a search operation that is presumably read-only.

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

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

A single, concise sentence that front-loads the action and resource. No wasted words, and the essential search dimensions are stated. This is efficient and well-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?

The description is too thin for a 7-parameter search tool with no output schema. It omits the geographic search feature (lat/long), doesn't explain result structure or pagination behavior, and provides no context on typical use cases. An agent would need to infer too much from the schema alone.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds no extra meaning beyond what the schema provides; it mentions search criteria that map to the 'query' parameter but doesn't elaborate on interactions (e.g., how type filters or lat/long bias work). Baseline 3 is appropriate when the schema is complete.

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 'Search' and the resource (sites, endpoints, clients) along with search criteria (name, address, MAC, IP). It is specific enough to distinguish from list/get tools, though it doesn't explicitly contrast with siblings like uisp_list_sites. The purpose is evident but could be more explicit about being the search counterpart.

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 listing tools or when to avoid it. The description doesn't mention that uisp_list_sites is for unfiltered listing or that this search is for targeted lookups. An agent gets no decision support for tool selection.

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