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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral context about what kind of data is returned, such as storage allocation, sub-account counts, and address details. It does not discuss permissions or error conditions, but for a read-only get operation this is acceptable.

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 names the action, the resource, the lookup key, and the important output categories. There is no filler 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 read-only lookup with two parameters and no output schema, the description covers the essential purpose, scope, and return-content highlights. It does not describe exact response formatting or the effect of includeDeletedSubAccounts, but those are largely covered by the schema and the operation's simplicity.

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 individual parameters are already documented in the input schema. The description does not add extra meaning to channelAccountId or includeDeletedSubAccounts beyond what the schema states, which is fine given full 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 clearly identifies the operation ('Get'), the specific resource ('Channel Account by ID'), and the added value ('detailed information including storage allocation, sub-account counts, and address details'). It is immediately distinguishable from sibling tools like list_channel_accounts, which filter or list entities.

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 establishes clear usage context: call this when you need a single Channel Account's details identified by ID, not when you need a list. It does not explicitly name alternatives or exclusion criteria, but the 'by ID' contrast with sibling list tools is clear enough.

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 readOnlyHint annotation already signals safety, and the description adds useful behavioral context by stating what the response includes ('storage, billing, and sub-account counts'). It does not contradict the annotation and gives enough detail for a read operation without claiming side effects.

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

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

The description is a single focused sentence that front-loads the core purpose and provides the most important response details without fluff or repetition.

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

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

For a simple read-only get-by-ID tool with two parameters and full schema coverage, the description adequately covers the return content ('storage, billing, and sub-account counts'). It lacks guidance on alternatives and error/edge-case behavior, but those are reasonably inferable and partially covered by the readOnlyHint annotation.

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 slight context by mentioning sub-account counts, which relates to the includeDeletedSubAccounts parameter, but it does not meaningfully expand on either parameter 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 names the specific verb ('Get'), the resource ('Control Account'), and a unique identifier ('by ID'). It also lists the kind of information returned ('storage, billing, and sub-account counts'), which distinguishes it from sibling tools like list_control_accounts and get_control_account_usage.

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

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

The description implies when to use it: when you have a specific control account ID and need its detailed information. However, it does not explicitly state when not to use it or mention alternatives such as list_control_accounts or get_control_account_usage.

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

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

Annotations already declare readOnlyHint=true, and the description only restates a read operation without adding details about errors, response shape, permissions, or pagination. No extra behavioral context is disclosed beyond what annotations provide, though there is no contradiction.

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 is front-loaded with the action and resource. It contains no filler and is appropriately sized for a one-parameter read-only 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?

For a simple get-by-ID tool with one required parameter and a readOnly annotation, the description captures the essential invocation details. It does not describe return shape, but that is less critical for a standard retrieval; mentioning the sibling list tool would improve it further.

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 fully documents utilizationId as 'Usage/Utilization ID' with 100% coverage, so the description does not need to add much. The description's 'by utilization ID' simply reinforces that the parameter is the lookup key.

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

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

States a specific verb ('Get') and resource ('Control Account usage record') and identifies the lookup key ('utilization ID'). The qualifier 'specific' plus the by-ID mechanism distinguishes it from list_control_account_usages.

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 'specific ... by utilization ID' implies the tool is for retrieving one known record rather than listing. However, there is no explicit alternative routing (e.g., 'use list_control_account_usages to enumerate records') or when-not condition.

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

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

Annotations provide readOnlyHint=true and the description ('Get') is consistent, so there is no contradiction. The description adds output-content context (billing breakdown categories) but does not disclose behavioral details such as error conditions, data scope, or response structure; given the read-only annotation, this is adequate but not rich.

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

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

One sentence that front-loads the primary action and resource, then adds relevant detail about the breakdown. 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 single-parameter read-only lookup with no output schema, the description is mostly sufficient: it names the resource, selection key, and return-value highlights. It could be stronger by referencing list_invoices as the discovery path, but nothing essential is missing 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?

The input schema fully documents invoiceId as an integer with description 'Invoice ID' (100% coverage), so the schema carries the parameter semantics. The description's 'by ID' simply reuses that concept without adding format, source, or constraints.

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 concrete resource ('specific invoice'), and identifier-based selection ('by ID'), which clearly separates it from listing tools like list_invoices. It also previews the expected content ('full billing breakdown including storage, API calls, egress, and ingress costs'), making the tool's function 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?

There is no explicit guidance about when to prefer this tool over siblings such as list_invoices or get_usage. The phrasing 'specific invoice by ID' implies it is for fetching one known invoice, but the description does not name alternatives or state 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?

Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds useful context about the return payload including profile, role, and security information, but does not mention possible error behavior, permissions, or other operational details. This is adequate but not rich.

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

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

A single, front-loaded sentence that communicates the operation, target, and returned information without any filler. Every word contributes meaning.

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

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

For a simple one-parameter read-only tool with a readOnlyHint annotation, the description is largely complete. It names the key output categories (profile, role, security info), which helps an agent understand what it will receive, though it does not describe error cases or explicitly contrast with list_members.

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 memberId is already fully documented in the schema. The description's mention of 'by ID' reinforces the parameter's purpose but adds no new format, constraint, or semantic detail 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 clearly states the action ('Get'), the resource ('specific Sub-Account member by ID'), and the expected output ('detailed profile, role, and security information'). It is easily distinguished from siblings like list_members, which are for listing rather than fetching a single member.

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 ID' makes the usage context clear: this tool is for fetching one specific member when an ID is known, as opposed to listing members. It does not explicitly name the alternative list_members or describe when not to use it, so it falls just 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?

readOnlyHint=true is already provided by annotations, and the verb 'Get' aligns with that. The description adds the sign-up context but does not disclose return format, ordering, or other behavioral details; with annotations covering the safety profile, this is adequate but not exceptional.

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 with no filler. Every word is informative and the key context 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?

This is a zero-parameter, read-only list tool. The description tells the agent exactly what is returned and in what context, so nothing essential is missing for correct invocation.

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

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

The tool has zero parameters, so the baseline of 4 applies. There is no parameter documentation burden for the description to carry.

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 concrete resource ('list of available storage amount options'), and a clear context ('Standalone Account sign-up'). This makes it easy to distinguish from sibling list tools like list_standalone_accounts.

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 'for Standalone Account sign-up' gives clear context for when this tool is relevant. It does not explicitly name alternatives or state when not to use it, but the intended use case is evident.

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 readOnlyHint=true annotation, the safety profile is already established. The description adds value by disclosing that response includes storage, keys only when requested, and parent hierarchy. It does not contradict the annotation and provides useful behavioral 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?

A single, focused sentence that front-loads the core purpose and immediately mentions key response details. There is no wasted wording or redundant restatement of the tool name.

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 key response aspects and the conditions for including keys. Given that all parameters are documented in the schema and the tool is a read-only single-record fetch, the description is sufficiently complete for an agent to call it correctly.

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

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

Schema description coverage is 100%, so the parameters are already well-documented in the schema. The description adds marginal context by mentioning keys when requested, but does not provide substantial meaning beyond what the input schema already states.

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

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

The description clearly states the verb 'Get' and specific resource 'Sub-Account by ID', and adds detail about storage, optional keys, and parent account hierarchy. This makes it easy to distinguish from sibling list tools like list_sub_accounts.

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 a single-item lookup by ID, which distinguishes it from list_sub_accounts. It does not explicitly state when to prefer this tool over alternatives, but the context is clear enough for an agent to infer the appropriate use case.

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 readOnlyHint annotation already signals the safe read-only nature. The description adds that the response includes 'full daily metrics,' which is useful return-oriented context, but it does not disclose other behavioral traits like error handling or authentication requirements. This is adequate given the annotation coverage.

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

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

A single, front-loaded sentence with no filler. It efficiently communicates the action, resource, identifier, and a key output characteristic.

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

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

For a simple single-parameter read tool with a readOnly annotation, the description covers the essential elements: what, which resource, how to identify it, and a hint of the return content ('full daily metrics'). Without an output schema, a bit more specificity about the metrics would improve completeness, but the current level is sufficient for basic invocation.

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

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

Schema description coverage is 100%, and the parameter 'utilizationId' is self-explanatory. The description only reaffirms the parameter name without adding new semantic detail, so it stays at the baseline for fully-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 uses a specific verb ('Get'), identifies the resource ('Sub-Account usage record'), and states the lookup key ('utilization ID'). It also distinguishes itself from siblings like list_usages (specific vs. list) and get_control_account_usage (sub-account vs. control account).

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 the right context: use when you have a utilization ID and need a single sub-account usage record with daily metrics. It does not explicitly name alternatives or exclusions, but the 'Sub-Account' and 'specific' wording provide enough directional guidance relative to the sibling tools.

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

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

Annotations already declare readOnlyHint=true, covering the safety profile. The description adds a meaningful permission-scope note ('within your permissions') and clarifies the domain role of Channel Accounts. However, it does not disclose operational behaviors such as pagination behavior, return shape, or how deleted sub-accounts affect counts, so it adds only modest value beyond the 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?

Two sentences, with the action, resource, and permission scope front-loaded in the first sentence. The second sentence provides useful domain context without redundancy. There is no filler and no unnecessary repetition of schema or annotation 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 read-only list endpoint with 8 optional parameters that are fully described in the schema and no required inputs, the description covers the essential operational context: what is listed and under what permissions. The main gaps are the lack of explicit sibling differentiation and no description of the response shape, but those are relatively minor for a straightforward list operation.

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

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

Schema description coverage is 100%, so all 8 parameters already have individual descriptions and default values where applicable. The tool description itself adds no parameter-level detail beyond implying that the listing is unfiltered by default. This matches the baseline of 3 for fully documented 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 specific verb ('List'), a specific resource ('Channel Accounts'), and a scope ('within your permissions'), which makes the primary purpose clear. It also adds a short definition of Channel Accounts. It does not explicitly distinguish itself from siblings like get_channel_account or list_sub_accounts, but the resource term and list verb make confusion unlikely.

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

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

The description provides no explicit guidance about when to use this tool versus alternatives such as get_channel_account for a single account or list_sub_accounts for sub-accounts. The phrase 'within your permissions' hints at access constraints, but there is no when-to-use or when-not-to-use direction, leaving the agent to infer the right context from the tool name and schema.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered and the description need not restate it. The description adds useful context by naming the returned metric families, but it does not disclose default time-window behavior, pagination semantics, or how the 'latest' flag interacts with date filters. With the annotation covering safety, this is adequate but not rich.

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

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

Two sentences with zero filler. The verb and resource scope are front-loaded, and the second sentence earns its place by specifying exactly which metrics are returned. Nothing is redundant or padded.

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

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

For a read-only list tool with full schema coverage and no output schema, the description communicates the return content clearly, which is essential since no output schema exists. Minor gaps remain — no mention of default behavior when only controlAccountId is provided, no ordering criteria — but nothing an agent needs 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?

Schema description coverage is 100% — all 9 parameters already carry type and meaning in the schema, so the description need not compensate. The description adds nothing about parameter semantics, which is acceptable at the baseline given full 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?

States the verb 'List' with a specific resource (bucket-level utilization data for a Control Account) and enumerates the exact returned metrics (storage, egress, ingress, API call metrics). The 'bucket-level' qualifier implicitly distinguishes it from sibling list_control_account_usages (account-level) and list_sub_account_buckets (sub-account scope) 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?

No guidance on when to use this tool versus its siblings. It never mentions list_control_account_usages for account-level utilization or list_sub_account_buckets for sub-account buckets, leaving the agent to infer routing purely from tool names. There is no when/when-not guidance and no named alternatives.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is established. The description adds useful context by noting the result set is limited to accounts within permissions and by summarizing returned data categories, but it does not go deeper into pagination behavior or conditional sensitive data beyond what the schema's includeApiKey warning already states.

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 operation, the scope, and the key return content with no redundant words. It is compact while still being informative.

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 listing tool with no output schema, the description covers the main purpose, permission scope, and notable return fields. With all parameters fully described in the schema, the only minor gap is the lack of explicit statement about default pagination behavior, but that is already present in the schema parameter descriptions.

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

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

Schema description coverage is 100%, so all nine parameters are already documented with their meanings. The description does not need to repeat parameter details and adds only general context about the returned account details, which is sufficient given the full 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 clearly states the tool lists Control Accounts and scopes results to those within the caller's permissions. It also specifies the key return categories, distinguishing it from sub-resource tools like list_sub_accounts and list_control_account_usages, though it does not explicitly name alternatives.

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

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

The phrase 'List all Control Accounts' implies this is the enumeration tool for the Control Accounts resource itself, but it does not explicitly say when to use it instead of get_control_account, list_control_account_usages, or list_sub_accounts. Usage context is implied rather than explicitly guiding selection between 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 readOnlyHint annotation already signals a safe read operation. The descripetion adds context by specifying the aggregate nature, the plural control-account scope, and the daily metrics, which is useful behavior beyond the annotation. It does not disclose pagination behavior or default filter behavior, but the annotation lowers the burdden.

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 written sentence that leads with the action and resource, then states the return metrics. Every word adds value, and it is not padeded.

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

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

While the description communicates the core purpose and return contents, with 9 optional filter parameters and no output schema there is no explanation of default behavior (e.g., whether filters are required, how pagination works, or what happens when no filters are provided). The schema covers parameter details, but the holistic context for an agent deciding on invocation is incomplete.

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

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

Schema coverage is 100%, so all nine parameters are already well documented with descriptions. The description does not add param-specific meaning, but that's acceptable because the schema carries the load. The mention of 'daily metrics' hints at the date range parameters, but does not go further.

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 a specific resource ('usage data across Control Accounts'), and enumerates the actual metrics returned (storage, egress, ingress, API calls). It clearly distinguishes from siblings like list_usages or get_control_account_usage by scoping to control-account usage and aggregating daily metrics.

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 list_usages, get_control_account_usage, or list_sub_account_buckets. The description only states what the tool does, not under which circumstances it should be selected.

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

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

Annotations already declare readOnlyHint=true, so mutation-safety is covered. The description adds beyond the annotation by disclosing permission-based scoping and the invoice contents (storage, API call, data transfer costs). It does not describe pagination, sorting, or response format, but the annotation lowers the bar.

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

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

Single sentence with a clear verb and resource upfront and no filler. Every phrase adds information: list scope, permissions, and cost categories.

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

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

The tool is relatively complex (12 optional filters, no required parameters, no output schema), and the description covers only the broad purpose and cost contents. Pagination behavior and any default or fallback semantics are left to the schema's page/size documentation, and the output shape is unspecified. Still, the schema covers all inputs and the readOnly annotation covers safety, making it minimally workable.

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?

All 12 parameters have schema descriptions (100% coverage), so the baseline is 3. The description adds no parameter-specific semantics beyond the schema, and the cost-type list relates to the return value rather than inputs. The schema already documents filters and defaults.

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

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

Clearly states it lists invoices and scopes them to Sub-Accounts within the caller's permissions, adding the included cost categories. It is easily distinguished from the sibling get_invoice by the list-vs-single contrast, though it does not explicitly name get_invoice as the single-record alternative.

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

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

No explicit when-to-use guidance or mention of alternatives such as get_invoice for a single invoice. The only contextual hint is 'within your permissions,' which addresses data scope rather than choosing among tools. The agent is left to infer usage from the tool name and sibling list.

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

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

Annotations already declare readOnlyHint=true, and the description adds useful behavioral context: results are filtered by the caller's permissions and include user details, roles, and MFA status. It does not discuss pagination behavior, but page and size parameters are already documented in 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 a single front-loaded sentence: the primary action and resource come first, the parenthetical clarifies terminology, and the return contents are stated compactly. Every clause earns its place with no redundancy.

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

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

For a read-only list operation with fully documented parameters and a readOnlyHint annotation, the description is complete enough. It states the resource type, permission scoping, and return contents; the optional filters and pagination defaults are already captured in the 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%: all six optional parameters (id, page, size, status, username, subAccountId) are self-documented in the input schema. The description does not add parameter-level meaning, so it meets but does not exceed the baseline.

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

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

The description opens with a specific verb and resource: 'List all Sub-Account members' and clarifies these are Wasabi Console users. This differentiates it from sibling tools like get_member (single member) and list_sub_accounts (sub-account-level resource), and the 'within your permissions' qualifier defines the 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 intended use is implied: use this tool when you need to enumerate Sub-Account members visible to the caller. However, the description does not explicitly mention when to prefer this over get_member for a single member or list_sub_accounts for account-level listing, nor does it state any 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?

The readOnlyHint annotation already signals this is a safe read operation, lowering the bar. The description adds meaningful behavioral scoping: it only returns accounts from the sign-up form and excludes hierarchy-attached accounts, which clarifies the tool's filtering behavior beyond the annotation.

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 redundant wording. The core action and resource are front-loaded, and the second sentence adds only the essential distinguishing context.

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 readOnlyHint, full schema documentation, and a clear scope statement, the description is strong. The absence of an output schema means return shape is not described, but for a straightforward list operation this is a minor gap.

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

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

Schema description coverage is 100%, so the schema fully documents all 10 optional filter parameters. The description itself adds no parameter-specific details, 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 uses the specific verb 'List' with the resource 'Standalone Accounts' and adds two distinguishing details: these accounts are created through the WACM Standalone Account Sign-Up Form and are not attached to the WACM hierarchy. This clearly differentiates it from sibling tools like list_control_accounts and list_sub_accounts.

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 'created through the WACM Standalone Account Sign-Up Form' and 'not attached to your WACM hierarchy' provides clear context for when this tool is appropriate. It does not explicitly name alternative tools or state when not to use it, but the scope is clear enough to guide selection among siblings.

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

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

The readOnlyHint annotation already establishes the safe read-only nature, and the description adds what kind of data is returned. It does not, however, disclose pagination behavior, response structure, or whether filters combine, though annotations lower the burden for these omissions.

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 front-load the core purpose and immediately note the return metrics. There is no filler or redundant restatement of schema details.

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

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

Given the read-only annotation and a fully described schema, the description is adequate: it states the scope, the returned metric types, and implies the list behavior. A minor gap is the lack of any mention of pagination/filter defaults or explicit alternative tool routing, but these are covered or inferable.

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?

All nine parameters are described in the input schema, so the description does not need to restate them. The description adds no extra meaning about parameter formats or interactions, which is acceptable at the baseline of 3 for full 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 uses a specific verb ('List') and a precise resource ('bucket-level utilization data for a Sub-Account'), and it states the returned metrics (storage, egress, ingress, API calls). This clearly separates it from sibling tools like list_control_account_buckets by specifying the account 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 the tool is for retrieving utilization metrics for a sub-account, but it gives no explicit guidance about when to choose this over alternatives such as list_control_account_buckets or list_usages. There is enough context to infer usage, but no exclusion or comparison is provided.

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

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

The description aligns with the readOnlyHint annotation and clarifies the scope 'within your permissions,' which is useful context. It also warns via the parameter schema that includeKeys returns sensitive credentials and defaults to false. However, the description itself does not disclose behavior like pagination or whether deleted sub-accounts are excluded by default; that detail is only in the parameter descriptions. Overall, the description adds meaningful scope context beyond the 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?

The description is a single, focused sentence that names the resource, the permission scope, and the return content. It is front-loaded with the primary action and resource. It does not waste words, though it could have added a brief note about filtering or sensitive keys without becoming verbose.

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

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

For a read-only list operation with all parameters self-describing in the schema, the description gives a reasonable starting point. However, it lacks guidance on pagination behavior, default filtering (e.g., are deleted accounts excluded?), and how to interpret the parent account information. Since there is no output schema and this is a listing endpoint with 11 optional filters, a bit more context—such as noting that results are paginated or that filters can be combined—would make it more 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?

Since schema description coverage is 100%, the schema already explains each parameter's meaning. The description adds a high-level summary of return contents but does not clarify parameter interactions, such as whether filters are combined or exclusive, or whether includeDeleted affects other filters. This does not go far beyond what the schema already provides, so the baseline 3 is appropriate.

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

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

The description clearly states the action ('List all Sub-Accounts') and the resource (Wasabi Console accounts), and it mentions what is returned: account details, storage allocation, and parent account information. It distinguishes from a generic list by scoping to sub-accounts, though it does not explicitly differentiate from sibling tools like list_channel_accounts or list_control_accounts by name.

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

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

The description implies usage: call this to list sub-accounts within your permissions. It does not provide explicit when-to-use vs alternatives or exclusions, such as 'use get_sub_account for a single account' or 'use list_control_accounts for parent-level accounts.' The context is clear enough for a straightforward listing operation, but no direct guidance is given among the many sibling tools.

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

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

readOnlyHint=true already discloses the safety profile, and the description adds useful context about daily granularity and the returned metrics. However, it does not explain behavioral details that matter for a 9-parameter list call, such as pagination defaults, the semantics of the latest flag, or how results are grouped; since the annotation covers the read-only nature, the bar is met at an adequate level without contradiction.

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 and 18 words, front-loading the action ('List Sub-Account level usage data') before the return-content detail. Every sentence earns its place with no filler or repetition of the tool name.

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 9 optional parameters and no output schema, so the description carries the burden of conveying response shape; it partially does by listing daily metrics but not the overall structure, units, or grouping. It also omits any guidance for distinguishing from list_control_account_usages given the same domain. Adequate for basic invocation but with clear gaps around response format and sibling selection.

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

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

Schema description coverage is 100%, so the baseline is 3 – every parameter (to, from, page, size, latest, subAccountId, controlAccountId, governanceAccountId, wasabiAccountNumber) is already documented in the schema. The description adds no parameter-specific meaning beyond the schema; the mention of 'daily metrics' aligns with the date range parameters but does not elevate understanding of any single parameter.

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: 'List Sub-Account level usage data', and the second sentence adds the returned metric types (storage, egress, ingress, API calls). The 'Sub-Account level' qualifier helps distinguish it from sibling list_control_account_usages, though no sibling is named explicitly and 'per Sub-Account' leaves grouping semantics slightly ambiguous.

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

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

No guidance is given on when to use this tool versus closely related siblings such as list_control_account_usages, get_control_account_usage, or get_usage. The description never states exclusions, prerequisites, or selection conditions; the only signal is the 'Sub-Account level' phrase, which requires the agent to infer the routing.

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