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

With no annotations provided, the description carries the full behavioral disclosure burden. It explicitly states it is 'side-effect-free' and 'does not initiate any MFA transaction,' which are the key behavioral traits an agent needs to know. It does not describe the exact return/error semantics, but for a no-argument validation tool this is a limited gap.

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

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

Two concise sentences with no filler. The primary purpose is front-loaded, and the side-effect clarification is an efficient second sentence that 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 zero-parameter, side-effect-free validation tool, the description covers what it does, what credentials are involved, and the key behavioral guarantee. There is no output schema, but the description already implies the result: whether the credentials are correct and the API is reachable. Nothing essential 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 input schema is empty, so the 0-parameter baseline of 4 applies. The description still adds relevant context by explaining that the ikey/skey/api host are configured credentials the tool checks, not parameters the agent must supply.

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 ('Validate'), a specific resource ('configured Duo credentials (ikey/skey/api host)'), and an expected outcome ('Auth API is reachable'). The purpose is unmistakable and clearly distinct from the sibling tools, which all operate on Duo entities rather than on the credential configuration itself.

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 clear this is a configuration/connectivity check and even calls out that it does not initiate an MFA transaction, telling the agent not to expect MFA behavior. It does not explicitly name alternative tools for related tasks, but the sibling set contains no other credential-checking tool, so the intended usage 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 full burden of behavioral disclosure. It states the scope of the log and the 'Get' verb implies a read-only operation, which is helpful. However, it does not disclose pagination behavior, the default time window when mintime is omitted, authorization requirements, or the response shape, all of which would be more relevant for a log retrieval tool without annotations.

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

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

A single, front-loaded sentence that names the action, the resource, and the data scope with no filler. The parenthetical '(v1)' is minor but informative. Every word 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 simple one-optional-parameter log reader, the description plus schema gives a usable baseline. However, with no output schema and no annotations, an agent lacks insight into the response format, pagination, or default behavior when mintime is absent. The tool is not complex, but a few more behavioral details would make the definition complete.

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

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

The input schema already provides 100% coverage for the single optional parameter mintime, so the description does not need to repeat it. The description adds no additional meaning about how mintime behaves or relates to the log, but the schema's own description is sufficient. 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 clearly identifies the specific resource ('administrator log (v1)') and its content ('actions taken by Duo administrators in this account'). It is immediately distinguishable from sibling log tools like duo_get_authentication_log and duo_get_telephony_log because it names the actor and 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 usage when an agent needs administrator action audit data, and it scopes the log to 'this account', but it does not explicitly tell the agent when to use this tool instead of the authentication or telephony log siblings, nor mention any exclusions. Context is present but guidance is left implicit.

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

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

No annotations are present, so the description must carry the behavioral disclosure. It does so by explaining pagination mechanics (pass back the comma-joined pair from metadata.next_offset) and by clarifying the log contains every MFA authentication event. This adds useful behavioral context beyond what the schema provides, though it does not mention rate limits or auth requirements.

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 sentences with no filler: purpose first, then parameter unit clarification, then pagination instructions. Every sentence earns its place and 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 5-parameter tool with 100% schema coverage and no output schema, the description sufficiently covers purpose, time filtering, and pagination. A brief note on the shape of the returned log entry would improve it, but an agent can invoke and paginate correctly with the information given.

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 baseline is 3. The description adds value by reiterating Unix epoch milliseconds for mintime/maxtime and, more importantly, specifying next_offset's exact format (comma-joined pair from metadata.next_offset), which is richer than the schema's generic 'Pagination cursor from a previous response'.

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

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

The description states a specific verb and resource: 'Get the authentication log (v2) - every MFA authentication event'. This clearly identifies the tool's function and distinguishes it from sibling log tools like duo_get_administrator_log and duo_get_telephony_log.

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 for use: it retrieves MFA authentication events in a time range. It does not explicitly exclude alternatives or name sibling tools, but the phrase 'authentication log' and 'MFA authentication event' makes its scope obvious relative to the sibling admin/telephony logs.

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 operation is read-only, what happens when the desktoptoken_id does not exist, whether 'full detail' includes nested fields, or any error/permission behavior. The term 'get' implies a read, but nothing about side effects or guarantees is disclosed.

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 with zero filler. It front-loads the verb and resource and communicates the essential identifying parameter immediately.

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

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

Adequate for a simple single-parameter get-by-id tool with 100% schema coverage and no output schema. The essentials are covered, but with no annotations, it could usefully disclose the read-only nature and return expectations to be fully complete. Not seriously deficient, but leaves room.

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 desktoptokenId fully. The description echoes 'by desktoptoken_id' but adds no new syntax, format, or meaning beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb+resource ('Get full detail for a single Duo Desktop token by desktoptoken_id') that clearly distinguishes it from the sibling duo_list_desktop_tokens, which lists tokens rather than fetching one. An agent can tell them apart 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?

The intent is implied: use this when you have a specific desktoptoken_id and need full detail on a single token. However, no explicit when-to-use guidance or exclusions are given, nor any mention of when duo_list_desktop_tokens would be preferable. The usage context is inferable but not stated.

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

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

No annotations are present, so the description carries the full behavioral burden. It says 'Get full detail' but provides no details about response content, error cases, permissions, or side effects. 'Full detail' is vague and does not add meaningful behavioral context beyond the action of getting.

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

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

One short sentence, front-loaded with verb and resource, no wasted words. It is appropriately sized for a simple single-parameter getter.

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 clarify what 'full detail' means. It does not specify return fields or behavior on missing/invalid IDs. The description is adequate for a trivial tool but leaves ambiguity about the response shape.

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% (groupId, string, 'Duo group_id'), so the baseline is 3. The description restates 'by group_id' but adds no new semantics about the parameter's format, source, or constraints. It does not compensate or expand beyond the schema.

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

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

States 'Get full detail for a single group by group_id' – a specific verb (get), resource (group), and identifier (group_id). This clearly distinguishes it from sibling tools like duo_list_groups (lists all groups) and duo_list_group_users (lists members of a group). The purpose is unambiguous.

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

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

The description gives no when-to-use guidance. It does not mention alternatives such as duo_list_groups for browsing groups or duo_list_group_users for membership. An agent must infer from the name that this retrieves a specific group; no explicit selection criteria or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it retrieves full detail, but does not indicate whether the operation is read-only, what happens if the token is not found, any permission requirements, or rate limits. The description adds little beyond the action itself, leaving the tool's behavior opaque.

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, tightly worded sentence with no filler. It front-loads the verb and resource, and the scope ('single') is stated upfront. 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 single-parameter get tool with no output schema, the description is reasonably complete but leaves room for improvement. 'Full detail' hints at a rich response but does not specify what fields are included or how errors are handled (e.g., not-found responses). While not a critical gap, an agent might benefit from knowing the expected response structure or any constraints, so it sits at an adequate-but-not-excellent level.

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 states 'Duo hardware token_id.' The description adds 'by token_id,' which is essentially the same information. Since the schema fully documents the parameter, the description adds minimal extra meaning, warranting 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 states a specific verb ('Get full detail') and a specific resource ('single hardware token') keyed by token_id. It clearly distinguishes this from sibling tools like duo_list_hardware_tokens (list) and duo_get_desktop_token (desktop token), leaving no ambiguity about what this tool does.

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: one would use this tool to fetch details for a specific hardware token rather than listing tokens or getting a desktop token. However, the description does not explicitly state when to prefer this over siblings or mention any exclusions (e.g., 'for desktop tokens use duo_get_desktop_token'). It relies on the agent to infer from the tool name and sibling list, so it meets the 'implied usage' baseline.

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 explicitly states that only metadata is returned and secret keys are stripped before response, which is valuable behavioral information for an agent. It does not discuss error cases or rate limits, but the core safety-relevant behavior is disclosed.

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 tightly written sentences with no filler. The main operation is front-loaded, and the important secret-stripping note is included without bloat.

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

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

The tool has one documented parameter and a straightforward purpose. The description explains what the tool returns, how to identify the integration, and what it deliberately omits. Without an output schema, a bit more detail about the metadata structure could help, but this is adequate for reliable 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 schema already documents the integrationKey parameter. The description reinforces that it is used for a single integration lookup but adds no format, validation, or additional semantic detail 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 clearly states the operation: retrieve full metadata for a single integration by integration_key. It distinguishes itself from sibling tools like duo_list_integrations and duo_get_user by specifying the unique resource and lookup method.

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 clearly implies this tool is for fetching one integration when you already have its integration_key. It does not explicitly name duo_list_integrations as the alternative for enumeration, but the scoping is clear enough to guide selection.

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

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

With no annotations, the description carries the full burden. 'Get full detail' signals a read-only fetch and implies a complete object is returned, but it does not disclose behavior for missing IDs, authentication requirements, or error responses. Adequate for a simple getter, but minimal.

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

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

One short, front-loaded sentence with zero filler. Every word contributes to the tool's purpose and lookup method.

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 get-by-ID tool with no output schema, the description is nearly sufficient. It clearly identifies the input and the expected result ('full detail'). It could note response shape or error behavior, but the simplicity of the tool lowers the bar.

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% because the lone parameter phoneId is described as 'Duo phone_id.' The description only repeats that the phone is looked up by this ID and adds no new semantic detail, so baseline 3 applies.

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

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

The description states a specific verb ('Get'), a precise resource ('full detail for a single phone'), and the lookup key ('by phone_id'). This clearly differentiates it from list-style sibling tools like duo_list_phones and duo_list_user_phones.

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 'by phone_id' clearly implies this tool is for fetching one known phone, as opposed to enumerating phones with list tools. It does not explicitly name alternatives or exclusion conditions, but the intended usage context 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, the description carries the behavioral transparency burden. It adds useful pagination behavior by explaining how to use next_offset with a comma-joined pair from metadata.next_offset. However, it does not mention ordering, output shape, or other behavioral traits an agent might need.

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, front-loaded with the core purpose and followed by the key pagination detail. Every sentence earns its place with no redundancy or filler.

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

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

For a read-only log tool with all optional parameters, the description covers purpose and pagination mechanics. But with no output schema and no annotations, it could be more complete by mentioning what fields or event data will be returned or how time constraints affect results.

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 baseline is 3. The description adds real value by clarifying the next_offset format as a comma-joined pair from the previous response's metadata.next_offset, going beyond the schema's generic 'Pagination cursor from a previous response'.

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 a specific verb and resource: 'Get the telephony log (v2)'. It also specifies the content as 'phone call/SMS credit usage events', which differentiates it from sibling log tools like authentication and administrator logs.

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 this tool through 'phone call/SMS credit usage events', but it does not explicitly state alternatives or when not to use it. The sibling tools provide context, but the description itself offers no direct comparison or exclusions.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool returns a user's full detail including status and enrolled-factor summary, which implies a read-only operation. However, it does not mention error behavior, rate limits, or any other side effects. The provided info is minimal but not misleading.

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, compact sentence with the primary action and key details front-loaded. There is no wasted text, making it highly efficient.

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

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

With no output schema, the description gives a partial idea of the return value by mentioning status and enrolled-factor summary, but does not enumerate all fields returned. For a simple get tool with one parameter, this is acceptable, but it could be more explicit about the full response structure or error handling.

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 describes the single parameter 'userId' as 'Duo user_id', and the description repeats 'by user_id'. With 100% schema coverage, the baseline is 3; the description adds no additional meaning beyond the schema, so a 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?

Description uses a specific verb ('Get'), a clear resource ('user'), and scopes it to a single user by user_id, while naming what's included (status and enrolled-factor summary). This clearly differentiates it from sibling list tools like duo_list_users and other get_* tools for different 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 usage when needing full detail for one user, but does not explicitly state when not to use it or name alternatives. It is clear from context that this is for single-user detail rather than lists, but there's no explicit routing 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?

The verb 'List' strongly implies a read-only operation, and the parenthetical 'platform, name, status' previews the returned fields. However, with no annotations provided, the description does not disclose pagination behavior, scope (e.g., org-wide vs. user-scoped), or response details beyond the field names.

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 that states the action, resource, and key output fields with no filler. It is compact and every word contributes value.

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 definition is adequate for a simple listing tool with pagination parameters already documented in the schema. It is somewhat incomplete because it does not clarify whether this returns all desktop tokens organization-wide or only tokens associated with a specific context, nor does it mention the pagination behavior explicitly.

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?

Both parameters (limit, offset) are fully described in the input schema with 100% coverage, so the schema already carries the semantic weight. The description adds no parameter-specific meaning, which matches the baseline 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 states a specific action ('List') and resource ('Duo Desktop tokens') and adds the returned fields in parentheses, making the purpose clear. It does not explicitly contrast with sibling tools like duo_list_user_tokens or duo_list_hardware_tokens, though the resource name itself differentiates 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?

There is no guidance on when to use this tool versus alternatives such as duo_get_desktop_token, duo_list_user_tokens, or duo_list_hardware_tokens. The description only states what it lists and leaves the selection context entirely 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?

There are no annotations, so the description carries the full burden. It indicates a non-mutating list operation and lists the fields returned, but it does not disclose pagination behavior, ordering, or access requirements. This is adequate but leaves some behavioral context implicit.

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 efficient sentence with the core action, scope, and return fields in a parenthetical. No wasted words or redundant information.

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 operation with only two optional pagination parameters, the description is nearly complete: it identifies the resource, scope, and output fields. It could note pagination behavior or contrast with the get-group sibling, but those are minor given the low complexity.

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 limit and offset are already documented. The description adds nothing about how pagination interacts with the returned list, so it meets the baseline but provides no extra semantic value.

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

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

The description states a specific verb ('List') and resource ('groups in the Duo account') and enumerates the returned fields, making the scope clear. This distinguishes it from sibling tools like duo_get_group and duo_list_group_users without requiring schema inspection.

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 the name and wording: call it when you need a paginated list of all Duo groups. However, the description does not explicitly state when to prefer it over duo_get_group or duo_list_group_users, nor does it give 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?

With no annotations, the description carries the full burden, but it only says 'List'. It does not disclose pagination behavior, return format/contents, error handling, or any access requirements. 'List' implies read-only, but little behavioral context is added beyond that.

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

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

The description is a single focused sentence with no filler and front-loads the main action. It is concise, though slightly terse for an unannotated tool.

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

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

There is no output schema and no annotations, so the description should compensate by explaining return values or edge cases. It does neither; an agent may not know what the response looks like, whether pagination is automatic, or how errors are surfaced.

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 documents all three parameters. The tool description adds no extra parameter meaning beyond what the schema provides, which matches the baseline for well-covered schemas.

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

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

The description states a clear verb ('List') and a specific resource ('users belonging to a group'), so an agent can infer this is a group-membership lookup. It does not explicitly differentiate from sibling tools like duo_list_users, but the phrasing is unambiguous enough.

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 duo_list_users or duo_list_user_groups. The intended use is implied by the name and description, but no explicit conditions or exclusions 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?

With no annotations provided, the description carries the behavioral burden. It explicitly discloses an important safety guarantee, 'Never returns a seed/secret', and the verb 'List' signals a read-only operation; this is more transparent than a bare list endpoint description.

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 concise sentence, front-loads the operation and resource, and earns its place with both filter guidance and a critical caveat. There is no filler or redundant restating of the schema.

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

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

For a list tool with no output schema, the description covers resource scope, filtering, token categories, and a security guarantee, which is sufficiently complete. Minor gaps remain around pagination behavior and explicit sibling routing, though pagination is already reflected in the limit/offset parameters.

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 all parameters (100% coverage), so the baseline is 3. The description adds meaning by listing concrete token types (HOTP/TOTP/YubiKey), which helps an agent understand valid values for the 'type' filter beyond the schema's generic 'Filter by token type.'

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 hardware tokens' and names the categories HOTP/TOTP/YubiKey. It also establishes account scope, distinguishing it from sibling tools like duo_list_user_tokens and duo_list_desktop_tokens.

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 states the optional filtering by type/serial and makes clear this is an account-wide listing. It does not explicitly name alternatives or when-not-to-use cases, but the scope and resource type give an agent enough context to avoid user-scoped siblings.

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

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

The description discloses a meaningful behavioral trait: secret keys are stripped before the tool returns a response. This is valuable context beyond the schema and annotations (which are absent). It also implies a read-only operation. However, it does not mention pagination behavior or rate limits, but the secret-stripping disclosure is a strong addition.

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

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

Two sentences with no wasted words. The core purpose and returned fields are front-loaded, and the security-relevant behavior is stated succinctly in 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 list tool with two optional pagination parameters and no output schema, the description is nearly complete. It covers what is returned and a key security behavior. It could mention that pagination is supported, but the schema already covers limit/offset, so the description is sufficient.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (limit and offset). The description adds no additional parameter semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('List') and resource ('integrations configured in the Duo account') and enumerates the returned fields (integration_key, name, type, status). It clearly distinguishes from siblings like duo_get_integration (which fetches a single integration) and other list tools for different 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 usage for listing integrations but does not explicitly state when to prefer this over duo_get_integration or other list tools. It provides no exclusions or alternative routing. The context is clear enough for an agent to infer, but there is no explicit 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, the description carries the behavioral burden. It usefully discloses that the response contains phone metadata and flags the data as PII, and 'List' implies a read-only operation. However, it does not mention pagination behavior, rate limits, or permission requirements beyond the PII warning.

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

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

Two short sentences front-load the action and scope, then the return fields. There is no filler or repetitive content; every sentence adds useful information.

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 list tool with fully documented parameters, the description covers purpose, optional filters, and return fields, including a PII flag. It is missing explicit routing to sibling tools and pagination default/max details, but those are minor given the schema coverage and simple operational profile.

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 four parameters. The description reinforces that number and extension are optional filters but adds no new semantic detail beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses a specific verb, 'List,' with a clear resource: 'phones in the Duo account.' It distinguishes account-level listing from the user-scoped sibling tool by saying 'in the Duo account,' but it does not explicitly name or contrast with duo_list_user_phones or duo_get_phone.

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 about when to use this tool instead of sibling tools such as duo_list_user_phones or duo_get_phone. It states what the tool does but does not provide conditions, 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?

No annotations are supplied, so the description must carry the behavioral disclosure burden. It only says 'List' and gives no information about pagination behavior, error conditions, authentication requirements, or what a group object 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?

The description is one short sentence with no filler words; the core action and scope are front-loaded. Nothing in it is redundant with the schema.

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 operation with fully documented parameters this is minimally viable, but the absence of an output schema, annotations, and any behavioral notes leaves clear gaps. An agent would not know the response shape or paging behavior beyond the bare limit/offset parameters.

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%; the schema already documents userId, limit, and offset adequately for invocation. The description adds no extra parameter meaning beyond mapping 'a user' to userId, so the baseline 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 uses a concrete verb and resource ('List the groups a user belongs to'), and the possessive 'a user' scopes it to a single user's memberships, distinguishing it from siblings like duo_list_groups and duo_list_group_users. It does not explicitly name alternatives, so it stops short of a 5.

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

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

There is no guidance about when to choose this tool over related list tools such as duo_list_groups, duo_get_group, or other user-centric listers. The only implied context is that a userId is involved; no exclusions or alternative conditions are 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?

With no annotations, the description carries the full behavioral disclosure burden. It communicates that the operation is a read-only listing, names the returned fields, and flags the data as PII—useful context beyond the schema. It does not mention auth requirements or pagination behavior, but these are less critical for a simple list operation.

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 a useful parenthetical. The verb and resource are front-loaded, and every word adds value.

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 complete parameter schema coverage and no output schema, the description provides enough context: it states the scope, what is returned, and the PII sensitivity. It could be slightly more explicit about pagination or how it differs from the global phone-listing sibling, but it is 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?

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific meaning, but it does not need to because the schema already documents userId, limit, and offset clearly.

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 ('phones enrolled to a user'), which clearly distinguishes this tool from the global duo_list_phones and other user-scoped list tools. It also names the key returned dimensions (number, platform/OS, capabilities), making the tool's purpose immediately identifiable.

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 'enrolled to a user' implies this is the tool for retrieving a specific user's phones, but it never explicitly states when to use this over duo_list_phones or other alternatives. No exclusions or alternative names are mentioned, so usage guidance is present only by 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?

No annotations are present, so the description carries the full burden. It discloses that the data is PII and classified as isAdmin, which is a useful sensitivity note. However, it does not explicitly state that this is a read-only operation, mention rate limits, pagination behavior beyond schema params, or what happens when no users match. For a list operation, these are minor gaps, but the description adds only the PII context beyond the schema.

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

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

The description is two sentences, front-loaded with the core action ('List users in the Duo account'), and the second sentence efficiently lists return fields and the PII/classification note. Every word earns its place, with no fluff 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?

The description covers the action, optional filter, and returned fields, which is sufficient for a list endpoint with three optional parameters and no output schema. It lacks explicit guidance on default pagination or rate limits, but the schema already covers limit/offset. The PII note adds important context. Overall, an agent has enough to invoke it correctly, though it could note that it returns all users by default when no username is given.

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

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

Schema description coverage is 100% for all three parameters (limit, offset, username). The description's mention of 'optionally filtered by exact username' adds nothing beyond the schema's existing description. Since the schema already documents each parameter's purpose and behavior, the description provides no additional semantic value, placing it at the baseline 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 tool lists users in the Duo account, with an optional exact-username filter. It also enumerates the returned metadata fields, which differentiates it from sibling tools like duo_get_user (which fetches a single user) and the various list_* tools for phones, tokens, etc. The verb and resource are specific.

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

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

The description implies usage (list users for directory queries) and mentions the optional username filter, but it does not explicitly contrast with alternatives such as duo_get_user for a single user or duo_list_group_users for group-scoped listings. No when-not guidance is provided, though the purpose is clear enough for an agent to infer when to use it.

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

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

With no annotations provided, the description carries the behavioral disclosure burden, and it does add one valuable safety-relevant fact: the secret seed is stripped from the response. It also indicates output is limited to type and serial. However, it says nothing about pagination behavior, error cases, or authorization requirements, which would be useful for a 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?

A single sentence that front-loads the action and scope, then appends the two most decision-relevant facts (returned fields and the secret-stripping behavior) with zero filler or repetition. Every word 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 simple read-only list tool with fully documented parameters, the description covers the key facts an agent needs: what is listed, for whom, and the sensitive-data exclusion. Since there is no output schema, the lack of detail about the pagination envelope (result shape, totals) is a minor gap but does not prevent 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 already documents all three parameters with 100% coverage, including limit and offset semantics, so the description adds little parameter-level meaning. The only added value is the implicit link between the userId parameter and the 'enrolled to a user' scoping, plus the output-field note (type, serial), which matches the baseline for high schema coverage.

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

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

The description names a specific action and resource ('List the hardware tokens enrolled to a user') and clarifies the returned fields (type, serial), which clearly separates it from the global duo_list_hardware_tokens. However, it does not explicitly distinguish hardware tokens from the overlapping sibling tools duo_list_user_u2f_tokens and duo_list_user_webauthn_credentials, so an agent could be unsure which per-user token list fits its need.

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 'enrolled to a user' implies this is the tool to use when a specific user's hardware tokens are needed rather than the global token list, but it does not state when to choose this over the U2F or WebAuthn per-user tools, nor does it name any alternative explicitly. Usage context is inferable but not stated.

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

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

With no annotations, the description carries the full burden. It does usefully disclose that private key material is never returned, which is a meaningful behavioral guarantee. However, it does not mention authentication requirements, error behavior, or pagination semantics beyond what the schema already implies.

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 short sentence that front-loads the core purpose and adds a valuable safety note. Every word earns its place, and there is no redundant filler.

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

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

For a simple read-only list operation with fully documented parameters, the description is nearly complete. It covers the key behavioral guarantee (no private key material) and the resource scope, though it lacks an explicit return-value shape or edge-case details in the absence of 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?

Schema description coverage is 100%, so the schema already documents all three parameters clearly. The description adds little beyond restating the user-scoped nature of the listing ('enrolled to a user'), so it meets the baseline without adding significant new 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 uses a specific verb and resource: 'List the legacy U2F security keys enrolled to a user.' It clearly distinguishes this from similar sibling tools like webauthn_credentials and hardware tokens by specifying 'legacy U2F' and 'enrolled to a 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?

The description implies when to use the tool through its purpose, but it does not explicitly state when to choose this over sibling tools such as duo_list_user_webauthn_credentials or duo_list_user_tokens. There is no direct when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does add a valuable guarantee that private key material is never returned, but it does not mention authentication requirements, side effects, pagination behavior, or the response shape. The 'List' verb implies read-only, but more explicit behavioral context would be stronger.

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 focused sentences with no fluff. The main purpose is front-loaded, and the security guarantee in the second sentence earns its place by adding behavioral value.

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 fully documented parameters, the description covers purpose and a key security constraint. However, there is no output schema, so the description could usefully explain what the response contains (e.g., credential IDs, names, enrollment dates) beyond the private-key exclusion.

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 three parameters. The description adds no additional parameter-level meaning beyond the overall purpose, so the baseline 3 applies.

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

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

The description clearly identifies the operation: listing WebAuthn credentials enrolled to a user, with helpful clarification of security keys and platform authenticators. It does not explicitly differentiate from the sibling duo_list_user_u2f_tokens, so while the purpose is clear, sibling distinction is left to the reader.

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: call this when you need a user's enrolled WebAuthn credentials. However, there is no explicit when-to-use guidance, no mention of alternatives such as duo_list_user_u2f_tokens, and no exclusions, so the agent must infer when this tool is preferred over siblings.

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