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

With no annotations, the description carries the full burden of behavioral disclosure. It usefully explains that the messageID is the value returned by an inbound integration call and that the tool resolves or maps it to an AlertID, but it does not disclose behavior for unmatched messageIDs, error cases, or whether any side effects occur.

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 concise sentences, with the core purpose stated first and the key clarifying distinction second. Every sentence earns its place and there is no redundant phrasing.

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

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

For a single-parameter lookup tool, the description covers the main purpose and parameter semantics well. However, without an output schema or annotations, it would be stronger if it mentioned what happens when the messageID is not found or what the return value looks like.

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 message_id with 100% coverage, so the baseline is 3. The description adds meaningful semantic value by explicitly distinguishing the inbound messageID from the AlertID, which reduces the risk of passing the wrong identifier.

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 a specific verb ('Resolve') and resource ('AlertID') from a given inbound messageID, and clarifies that the messageID is not the AlertID. However, it does not differentiate this tool from the similarly named sibling alertops_get_alert_id_by_unique_inbound_id.

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 when you have an inbound integration messageID but gives no explicit guidance on when to prefer this tool over its sibling alertops_get_alert_id_by_unique_inbound_id. No exclusions or alternative conditions 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 are provided, so the description carries the full burden of disclosing behavior. It clarifies the ID semantics but does not state whether the operation is read-only, what happens for unmapped IDs, whether any side effects occur, or what the response contains.

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

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

Two short sentences with no filler. The main action is stated first, and the crucial clarification about the input occupies the second sentence.

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 resolver, the core purpose and input semantics are covered. However, with no output schema or annotations, the description does not explain the return value shape, missing-ID behavior, or how this tool differs from the close sibling get_alert_id_by_inbound_message_id, leaving some important context unstated.

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

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

The schema already documents the parameter with 100% coverage, so the baseline is 3. The description adds value by emphasizing that uniqueInboundID is not the AlertID itself, helping prevent a likely semantic error when calling the tool.

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: resolve an AlertID from a uniqueInboundID, and explicitly distinguishes the input value from the AlertID itself. It does not explicitly contrast this tool with the similarly named sibling alertops_get_alert_id_by_inbound_message_id, so it stops short of full differentiation.

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

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

The description implies when to use the tool: when an inbound integration call returns a uniqueInboundID and the agent needs the corresponding AlertID. However, it gives no explicit guidance about when not to use it or how it relates to alternatives like alertops_get_alert_id_by_inbound_message_id.

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

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

No annotations are provided, so the description carries the full burden. It discloses a useful constraint ('max duration 3 months') and the Group ID dependency, but does not state permissions, error behavior, pagination, or response shape. The verb 'List' implies a read-only operation, but that is not made 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 a single, front-loaded sentence that states the core action, the date-range constraint, and the prerequisite without filler. Every word contributes to correct tool usage.

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

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

For a read-only scheduling tool with full schema coverage and no output schema, the description provides the key constraints (date range limit, Group ID prerequisite) and enough context to distinguish it from siblings. It does not describe the returned schedule format, but that is not essential for invoking the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful value by introducing the 3-month maximum duration constraint on the date range, which is not in the schema. It also reinforces the Group ID source, though that is already present in the schema.

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

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

The description clearly states the action ('List'), the specific resource ('a group's on-call schedule'), and the scope ('for a date range'). It also differentiates from siblings like alertops_get_user_schedule by specifying 'group' rather than 'user'.

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

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

It gives a clear prerequisite: 'Requires a Group ID from alertops_list_groups.' However, it does not explicitly compare with alternative tools such as alertops_get_user_schedule or alertops_get_oncall_now, nor state when not to use this tool.

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 disclosure burden. It clearly indicates a read-only, current-state lookup and describes the return content: each group and its current on-call member(s). It does not cover edge cases like empty groups or timezone handling, but for a simple list operation the behavior is adequately 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?

Two short sentences deliver the core purpose, scope, and return shape without waste. The most important information is front-loaded.

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, no output schema, and no annotations, the description provides enough to invoke it correctly and understand its return value. It could mention what happens when no one is on-call or how the current moment is interpreted, but these are minor gaps for a simple current-state lookup.

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 that group_id is optional, limits to a specific group, and references alertops_list_groups. The main description repeats the optional single-group behavior but adds no new meaning beyond the schema.

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

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

The description uses a specific verb ('List') with a clear resource ('who is on-call right now') and explicitly states the scope: every group or a single group. It also distinguishes the tool from schedule-related siblings by emphasizing 'right now' vs. schedules.

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 clear context: omit group_id to see all groups, or provide it to limit to one group, and the schema ties group_id to alertops_list_groups. It does not explicitly name alternative tools or state when not to use this tool, but the intended usage is unambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns that the data "Contains contact PII," which is important context for handling sensitive information. It also indicates the output includes enabled status, giving the agent useful behavioral expectations beyond a bare 'get' verb.

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

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

Two sentences deliver the core purpose, output detail, privacy warning, and input dependency with no filler. The most important information is front-loaded, and every sentence 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 single-parameter read-only list tool with no output schema, the description is nearly complete: it states what is listed, that enabled status is included, that the data is sensitive, and how to obtain the username. It could be slightly more explicit about the exact return structure, but nothing essential for correct invocation is missing.

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

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

The schema already documents the only parameter with 100% coverage: "Username, from alertops_list_users." The description repeats this dependency but does not add new detail about format, validation, or edge cases. 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 uses a specific verb and resource: "List a user's configured contact methods." It also clarifies the scope (email, phone/SMS, enabled status) and is clearly distinct from siblings like alertops_list_users and alertops_get_user_schedule, so an agent can identify the right tool without 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 supplies a clear prerequisite: "Requires a username from alertops_list_users." This tells the agent where the input must come from and implies the workflow of listing users first. It does not explicitly name alternatives or exclusions, but the tool's purpose is specific enough that there is no obvious sibling conflict.

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 context. It contributes a useful constraint (max 3-month date range) and a dependency on a prior call. However, it does not disclose safety (read-only), return format, or behavior for empty schedules, leaving notable gaps for a tool that must be invoked without 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?

Two sentences with zero filler. The first sentence states the action and the key constraint; the second gives the input prerequisite. Purpose is front-loaded and the constraint is placed where it is most relevant.

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, parameter-rich list operation, the description plus fully described schema supplies what is needed to invoke it correctly: the target user, date range, and the upstream source for the username. It could be more complete by mentioning return behavior or explicitly routing to alternatives, but nothing critical is missing for calling 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 the 3-month range cap and indirectly reinforces user_name's source, but the schema already documents each parameter including the alertops_list_users dependency for user_name.

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

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

The description opens with a strong verb+resource pair ('List a specific user's on-call schedule') and immediately scopes it by date range and a 3-month maximum. This distinguishes it from sibling tools like alertops_get_group_schedule and alertops_get_oncall_now, which target different schedules.

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

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

It gives a clear prerequisite for using the tool: the username must come from alertops_list_users, which tells the agent when this tool is applicable in a workflow. It does not explicitly state when not to use it or name alternative tools, so it falls short of a 5.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses default sort order, pagination limits, filter behavior, and the direct usability of returned AlertIDs. It does not describe the return payload shape or rate limits, but for a read-only list operation this is a solid 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?

Three dense, front-loaded sentences cover behavior, filters, pagination, and sibling differentiation with no filler. Every sentence 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 12-parameter tool with no required parameters and no annotations, the description covers all major filter groups, pagination semantics, and sibling boundaries. It is slightly shy of perfect because there is no output schema and the description does not describe the shape of the returned alert list, though that is not essential for invocation.

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

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

Schema description coverage is 100%, so the structured schema already documents every parameter. The description adds useful grouping (status, created/closed dates, group/integration/escalation IDs, pagination) but no significant per-parameter meaning beyond what the schema provides.

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

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

The description states the exact operation ('List alerts'), the default ordering ('newest first by default'), and enumerates all filter dimensions. It also draws a clear boundary against message-level lookup siblings, so an agent can distinguish this tool from alertops_get_alert_id_by_* immediately.

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

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

It specifies the main use case (listing/filtering alerts with pagination) and explicitly warns that message-level lookups by messageID/uniqueInboundID are separate tools. It does not name those sibling tools or give an explicit 'use X when' statement, but the context is clear.

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 states the output is a mapping of ID to name, which is a basic behavior, but it does not mention potential pagination, ordering, or any side effects (though for a read-only list tool these may not be relevant). The description is adequate but not rich; it neither contradicts annotations (none) nor adds significant behavioral detail.

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 wasted words. The primary purpose is front-loaded, and the second sentence adds valuable cross-tool context. It is efficiently structured and easily parseable by an agent.

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

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

For a tool with no parameters and no output schema, the description is fairly complete. It states the return format and explicitly indicates how the results are used by other tools. It does not mention error conditions or limits, but for a simple list operation these are not critical. The description covers what an agent needs to call it correctly and interpret the response.

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 coverage is 100% (trivially). Per the baseline for 0 params, a score of 4 is appropriate. The description does not need to explain parameters, and it correctly implies a no-parameter call.

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'), the resource ('all groups in the AlertOps account'), and the output format ('group ID -> group name'). It uniquely identifies the tool among siblings, which include list_alerts, list_users, list_topics, etc., by specifying groups.

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

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

It does not explicitly say when to use it versus alternatives, but it provides practical guidance by noting that group IDs from this response are usable by three other tools (alertops_list_alerts, alertops_get_oncall_now, alertops_get_group_schedule). This implicitly tells the agent to call this tool when group IDs are needed for those operations. There is no competing group-list tool, so exclusion guidance is unnecessary.

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. 'List' implies a read-only operation and the return mapping is disclosed, but the description does not explicitly state that no modifications are made, nor does it mention access requirements or response behavior beyond the ID-to-type mapping.

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 core action and resource are front-loaded, the parenthetical adds useful output-shape detail without bloat, and the final sentence explains a practical downstream use of the returned IDs.

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 with no output schema, the description is complete: it states the purpose, describes the return format with examples, and connects the output to alertops_list_alerts. No critical information needed to invoke it correctly is missing.

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

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

The tool has zero parameters, which sets the baseline at 4. The schema is empty and fully covered, so there are no parameter semantics for the description to clarify beyond confirming the account-level scope.

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

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

The description opens with a specific verb and resource: 'List configured inbound integrations in the AlertOps account'. It also clarifies the output shape as an 'integration rule ID -> integration type' mapping with concrete examples, and the mention of alertops_list_alerts helps distinguish it from sibling tools.

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

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

The statement that 'Integration Rule IDs from this response are usable by alertops_list_alerts' provides clear workflow context for when this tool is useful. It does not explicitly state when not to use it or name alternatives, so it falls just short of full 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?

With no annotations provided, the description carries the burden of behavioral disclosure. 'List all' clearly indicates a read-only enumeration and does not suggest any mutation or side effects. The purpose clause adds useful context about what topics are without overclaiming. A minor gap is the lack of comment on pagination or result size, but for a zero-parameter list tool this is not a significant deficiency.

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 core action ('List all message topics') and appends the purpose in a relative clause. Every word earns its place; there is no repetition, filler, or ambiguity.

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 is nearly complete: it states what is listed, where they are configured, and their purpose. It does not specify exact fields returned (e.g., topic ID, name, routing rules), but given the simplicity of the tool and absence of an output schema, the agent can successfully invoke it and interpret the result at a basic level. A slightly richer note on return values would push it to 5.

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 is empty (0 parameters), and the rules specify a baseline of 4 in that case. The description adds no parameter-specific meaning because none exists, which is appropriate. There is no need for the description to compensate for undocumented 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 uses a specific verb-resource pair ('List all message topics configured in the AlertOps account') and clearly identifies the resource as topics, which distinguishes it from sibling tools like alertops_list_alerts, alertops_list_users, and alertops_list_integrations. The additional purpose clause ('used to route inbound alerts to the right escalation/priority handling') further clarifies the tool's role.

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 clear context: this tool is used to see the message topics that govern inbound alert routing. It implies when this tool is relevant (when working with alert routing configuration), but it does not explicitly state 'use this instead of X' or name alternative tools for exclusion. This misses the 5 threshold but is stronger than a vague implication.

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. It clarifies the scope ('all users') and the fields returned, which adds some context, but it does not mention authentication requirements, pagination, rate limits, or explicitly state that the operation is read-only. The word 'List' implies non-mutating behavior, but the description is not fully 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?

Two tight sentences: the first front-loads the action and resource, the second adds valuable downstream context. There is no filler or 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 zero-parameter read-only list tool, the description is complete: it states the resource, the scope, the fields returned, and why the output matters for other tools. The absence of an output schema is mitigated by the explicit field list.

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

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

The tool has zero parameters and 100% schema description coverage, so the baseline is 4. The description does not need to explain parameter semantics; its mention of the returned usernames provides useful output context beyond the empty schema.

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

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

The description uses a specific verb ('List') and resource ('all users in the AlertOps account') and enumerates the returned fields. It is immediately distinguishable from sibling tools that operate on alerts, groups, topics, integrations, and schedules.

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

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

The description explicitly states that usernames from this response are required by alertops_get_user_contact_methods and alertops_get_user_schedule, giving clear contextual guidance on when to invoke this tool. It does not explicitly state when not to use it, but no alternative user-listing tool exists among the siblings.

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