TrueClicks

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

The description discloses the read-only nature ('Get') and the output format (JSONL), which goes beyond the provided annotations (readOnlyHint=true, destructiveHint=false). It also transparently explains the account ID field naming convention, which could otherwise be ambiguous. No contradictions with 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 concise (two sentences) and well-structured. It front-loads the primary purpose ('Get all accounts'), then adds necessary details about output format and ID resolution. No redundant or vague wording.

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

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

For a tool with no parameters and no output schema, the description is complete. It specifies what is returned (accounts with fields), the format (JSONL), and how to use the results (accountId resolution). It fully equips the agent to invoke the tool correctly.

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

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

The input schema is empty (0 parameters), so the baseline is 4. The description doesn't need to explain parameters, and it adds additional context about the output and ID usage. No parameter-related gaps exist.

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

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

The description clearly states the tool's purpose: 'Get all accounts' with specific output details (JSONL format and fields). It distinguishes itself from sibling tools by indicating this is the account listing tool, and the mention of resolving account IDs for other calls further clarifies its role.

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

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

The description explicitly tells when to use this tool: 'use this to resolve account ids before calling them' and clarifies the distinction between Id and ClientCustomerId field. This provides direct guidance for the agent, making it clear this is a prerequisite step for tools requiring accountId.

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 the output format (JSONL) and row semantics (one per assignment), which goes beyond the readOnlyHint annotation. It does not mention potential edge cases like large result sets, but for a simple read operation this is adequate.

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

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

The description is a single, concise sentence that directly states the purpose and output format. No unnecessary words 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 is sufficient for a simple list tool, but it does not specify the exact fields present in each row (e.g., account ID, label name). This minor gap is acceptable given the typical expectation of such a tool, but a bit more detail would make it fully complete.

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

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

The sole parameter 'accountIds' is fully documented in the schema description, including its optionality, meaning, and default behavior. The reference to the 'numeric Id field' from the account listing adds helpful context.

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

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

The description clearly states the tool retrieves account labels as JSONL, with a specific resource (account labels) and action (Get). It is distinct from sibling tools like 'account' which likely lists accounts, and 'account_label' 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 implies usage for retrieving account-label assignments, but does not explicitly contrast with alternatives or state when to prefer this tool over others. However, given the sibling set, the purpose is fairly evident, so it is not misleading.

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 safe read-only behavior is already captured by readOnlyHint=true and destructiveHint=false, so the description doesn't need to cover those. It adds useful behavioral context beyond the annotations: results are 'latest,' formatted as Markdown, aggregated per account, and represent a high-level roll-up across all audit rules. It does not contradict 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 just two sentences with clear front-loading of the action, target resource, and output format. There is no filler, and the phrase 'suitable for direct AI consumption' adds relevant guidance rather than being padding.

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, read-only tool with 100% schema coverage and no output schema, the description covers the main points an agent needs: what to call it for, the result format, and the aggregation level. It's slightly sparse on detail of what the Markdown summary actually contains, but the high-level roll-up context makes it sufficient for the intended use.

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 accountIds parameter already carries the specific true-natural language about TrueClicks account IDs, the ID type nuance, and the empty-array behavior. The description adds no new parameter semantics, so the baseline score of 3 applies.

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

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

The description gives a specific verb+resource ('Get the latest account-aggregated audit results') and states the output format (Markdown summary) and scope (high-level roll-up across all audit rules). This makes it clearly distinct from the per-rule and per-campaign audit siblings, even without naming them.

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

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

The description implies when to use this tool: when an account-level, high-level Markdown summary of audit results is needed. However, it never names or excludes alternatives like audit_rule_result or audit_rule_output_table, so in a list of many audit sibling tools the selection guidance is mostly left to inference.

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 significant behavior: the output format, the rule-key block structure, and the 30-day no-run exclusion. The readOnlyHint annotation already covers the read-only nature, and the description adds no conflicting information.

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 somewhat long but well-organized and directly relevant. It front-loads the core purpose and then explains formatting, striking a balance between completeness and brevity.

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 tool with no output schema, the description provides sufficient context: it explains the output format, the filtering condition (30-day window), and the purpose (raw findings). It does not need to elaborate on authentication or error handling given the tool's simplicity and the presence of sibling tools for historical data.

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 descriptions cover all four parameters completely, so the baseline is 3. The description does not add extra semantic detail beyond what the schema already provides, such as clarifying the relationship between accountId and campaignIds.

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

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

The description clearly states the tool's function: retrieving detailed output rows for the latest completed audit run for one or more rules. It also specifies the output format (multi-block CSV with rule keys and metadata) and distinguishes it from the historical variant by emphasizing 'latest completed.'

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 mentions that it provides raw findings behind a failing audit rule and that rules with no completed run in the last 30 days are omitted, giving practical guidance. However, it does not explicitly contrast with sibling tools like audit_rule_output_table_historical, though the 'latest completed' phrasing implies the difference.

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?

Beyond the readOnly annotation, the description discloses the exact output behavior: multi-block CSV with block headers, metadata lines, and omission of missing weeks. This transparently sets expectations for retrieval results without contradicting 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 well-structured and concise, delivering the tool's purpose, output format, and edge-case behavior in four short sentences. No filler or redundant phrases dilute the message.

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?

Since there is no output schema, the description provides enough detail about the response shape: block format, metadata line, CSV rows, and behavior for missing weeks. Combined with the complete parameter descriptions, an agent can understand the tool's functionality without ambiguity.

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

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

The input schema already covers 100% of parameters with clear descriptions, including accountId, ruleKeys, weekStartDates, optional campaignIds, and limit. The description does not add significant parameter-specific meaning beyond the schema, so a baseline score is appropriate.

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

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

The description states a specific verb 'Get' and resource: detailed audit rule output rows for one or more rules across multiple historical weeks. It clearly distinguishes historical retrieval from current output tables by emphasizing the multi-block historical CSV format and time comparison purpose.

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

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

The description explicitly says 'Use to compare how findings changed over time,' giving a clear when-to-use directive. It also clarifies week identification by Monday start dates and behavior for weeks with no completed run, which helps the agent know when to call this tool.

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

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

The description adds useful behavioral details beyond the annotations, such as 'Never returns disabled rules', grouping by type, and historical column appending. The readOnlyHint annotation already covers safety, and the description does not contradict it.

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 information-dense but not bloated. It follows a logical flow: result type, filtering, grouping, columns, and optional historical behavior. 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?

There is no output schema, so the description rightly explains return format and key columns. It is complete enough for typical use, though it omits edge-case behavior like empty accountIds, ordering, pagination, or error conditions.

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 with 100% coverage, and the description adds extra behavioral meaning, especially for numberOfWeeks ('historical weekly columns are appended, most recent first') and onlyFailed. It reinforces but does not merely echo the schema.

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

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

The description clearly states the verb ('Get'), the resource ('account-level audit rule results'), and the output format ('Markdown summary'). It also distinguishes itself as account-level, which helps separate it from campaign-level or output-table sibling tools.

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

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

Parameter usage is explained well (accountIds filtering, onlyFailed, numberOfWeeks), but the description does not explicitly say when to choose this tool over related siblings like audit_account_result, audit_rule_output_table, or audit_rule_result_campaign. Guidance is implied rather than explicit.

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

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

Beyond the read-only annotation, the description discloses the exact behavior regarding historical weeks, how results are filtered, and the meaning of cell values like 'Rows (0)' and '-'. It provides substantial operational details that an agent would need to interpret the output correctly.

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 verbose and repeats inclusion/exclusion logic in multiple places. While it is well-structured and front-loaded, the redundant clarifications could be condensed without losing meaning, making it less concise than ideal.

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 output format (Markdown summary), the inclusion rules, and the interpretation of historical data. It does not mention pagination or error handling, but for a read-only reporting tool, the provided context is largely 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?

All three parameters have descriptions that go beyond type definitions. For example, campaignIds explains the filtering behavior and the null/empty default, and numberOfWeeks clarifies the default and its effect. This provides clear semantic value 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 that the tool gets campaign-level audit rule results as a Markdown summary, and explicitly distinguishes it from account-level or rule-level results. It also defines the inclusion and exclusion criteria, making the purpose 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 explains the scope (single account, campaign-specific rules) and the inclusive/exclusive logic, but it does not explicitly compare this tool to sibling tools like audit_rule_result or audit_account_result. The selection is implied by the title and content, but not directly 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?

Annotations indicate read-only, open-world, and non-destructive behavior, and the description does not contradict them. It adds useful behavioral detail about output formatting and error handling, though it does not mention limits or pagination.

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 efficient and well structured, with examples that clarify usage. The micros renaming point is explained twice but the repetition serves to prevent a common mistake, so it remains justified.

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

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

Given no output schema, the description sufficiently explains the return format (TSV with header and rows) and error behavior. It does not cover edge cases like empty results or pagination, but it is complete enough for typical query execution.

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 complete, and the description adds significant meaning: it distinguishes accountId from Google Ads customer id, explains date dependencies, and gives concrete examples for fields, predicates, and ordering. This goes well beyond the raw 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 identifies the tool as executing a structured Google Ads GAQL query for one account and returning results as TSV. It specifies the resource and query nature, distinguishing it from listing/column-discovery sibling tools.

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

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

The description explains what the tool does but does not state when to use it versus alternatives like google_ads_report_columns or google_ads_reports_list. There is no explicit 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?

Annotations already indicate read-only and non-destructive behavior. The description adds that the output is 'raw CSV', providing specific behavior detail beyond the annotations. It does not mention error handling or side effects, but the read-only nature is well-covered.

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 immediately identifies the action, scope, and output format. It is concise and well-structured without unnecessary verbiage.

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 metadata retrieval tool with one parameter, the description is largely complete. It covers the main purpose and output format, though it could hint at how report names are sourced or what the CSV contains (e.g., headers) for additional clarity. Minor gaps do not hinder basic usage.

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 provides a 100% description for the reportName parameter. The tool description essentially repeats this information without adding new details such as allowed values, format constraints, or how to obtain valid report names. No additional semantic value is provided.

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

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

The description clearly states the action (getting column/field definitions) and the resource (a given Google Ads report) and specifies the output format as raw CSV. It effectively differentiates itself from sibling tools like google_ads_reports_list and google_ads_execute_report by focusing on metadata retrieval.

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

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

The description does not explicitly state when to use this tool versus alternatives. While the purpose is self-evident and the name suggests it is for retrieving column definitions, there is no direct guidance on use cases or contrast with sibling tools. This is adequate but not explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the read-only nature is known. The description adds valuable behavioral context by specifying the output format ('raw CSV') and the content (report/resource names in the GAQL schema), which goes beyond the annotations. No contradictions detected.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Get the list'), then specifies the content and output format. Every word contributes meaning, with 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 no-parameter, read-only list tool, the description is fully complete. It states what the tool returns (list of report definitions) and the format (raw CSV), which is all an agent needs to invoke it correctly. The lack of an output schema is compensated by this explicit return description.

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

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

This tool has zero parameters, and the schema description coverage is 100% (vacuously). Per the rubric, a baseline of 4 is appropriate. The description does not need to explain parameters since there are none, and it correctly avoids inventing any.

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

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

The description clearly states the tool's function: retrieving a list of available Google Ads report definitions (report/resource names) as raw CSV. It specifies the resource type and output format, making the purpose unambiguous. However, it does not explicitly distinguish itself from sibling tools like google_ads_report_columns, though the term 'report definitions' implies a difference.

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

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

The description implies usage context—when you need the list of report definitions—but does not explicitly state when to use this tool versus alternatives such as google_ads_execute_report or google_ads_report_columns. It provides clear context but no exclusions or comparative 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 description is transparent that this performs a read-only query (no destructive action) and returns TSV rows. The annotations already mark readOnlyHint and destructiveHint, and the description adds clarity about output format and automatically injected prefixes, covering behavior beyond the annotations 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 compact and information-dense, with a clear first sentence and practical examples. It is slightly longer than strictly necessary because of the extensive query examples, but those examples directly aid correct usage and do not waste space.

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

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

The description covers the essential context: what the tool does, what output format to expect, key parameter disambiguation, and query syntax. Since no output schema is provided, the description compensates by specifying TSV with a header row, which is sufficient for this dynamic report tool.

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

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

Both parameters are explained in detail: accountId is clearly distinguished from Meta's customer id and provided with context, and query is fully described with syntax rules, examples, and the note that the act_<accountId> prefix and access_token are auto-added. This is strong, concrete parameter guidance that goes 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 tool executes a Meta (Facebook) Marketing API query and returns results as TSV. It explicitly differentiates from Google Ads and Microsoft Ads report tools via the Meta-specific naming and API references, so an agent can distinguish it from sibling tools.

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

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

The description implicitly signals usage for Meta Ads reports by stating 'Meta (Facebook) Marketing API query' and contrasts with Google/Microsoft siblings in the sibling list. It gives concrete examples but does not explicitly state 'use this when you need Meta Ads data' or compare with other Meta report tools, leaving slightly to inference.

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 and destructiveHint annotations already indicate safety, and the description reinforces a read-only snapshot behavior by describing the TSV output and lack of date aggregation. It adds useful context about the output format and data scope.

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

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

The description is two sentences with no redundant wording. It front-loads the primary action and resource, then clarifies output format and scope in a compact way.

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 there is no output schema, the description sufficiently indicates the return format (TSV with header row). It also explains the snapshot nature and what the data represents, covering the main context needed for correct use.

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 three parameters are described in the schema with 100% coverage, so the description adds minimal additional parameter-level meaning. The existing parameter descriptions are adequate for understanding report name, columns, and account ID.

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 executes a Microsoft Ads bulk query for one account and returns entity/configuration rows in TSV format. It explicitly contrasts with time-bound performance metrics, distinguishing it from sibling reporting tools.

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

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

The description provides direct guidance on when to use this tool: for entity/configuration snapshots with no date range or aggregation, as opposed to time-bound performance metrics. This makes the appropriate context clear relative to the available 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 mark the operation read-only and non-destructive. The description adds transparency by specifying the TSV return format and by clarifying that it covers only performance reports, not config snapshots. There is no contradiction with the readOnlyHint 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?

The description is concise, well-structured, and free of redundant wording. It conveys the essential purpose, scope, required parameters, and output format in three clear sentences.

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

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

The description is sufficiently complete for a report-execution tool: it states the input constraints, the output format, and the scope boundary. Since no output schema is provided and the schema descriptions are thorough, no critical invocation context 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 already provides complete descriptions for all parameters, including the important clarification about accountId and the optional predicates. The main description only reiterates that startDate, endDate, and reportAggregation are required, adding little beyond the 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 action ('Execute a Microsoft Ads performance report query'), the target resource ('for one account over a date range'), and the output format ('TSV'). It also distinguishes itself from entity/configuration snapshots, making its purpose unambiguous relative to sibling tools.

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

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

The description provides useful when-to-use guidance by explicitly indicating it covers metric reports over a date range and not entity/configuration snapshots. It does not explicitly name sibling tools like ms_ads_execute_bulk_query or ms_ads_reports_list, but the scope distinction is clear enough for an agent to choose appropriately.

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 indicates no side effects. The description adds the concrete output format (CSV, one column name per row), which helps set expectations. No behavioral contradictions exist.

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

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

The description is very concise, with no redundant wording. It communicates the resource, output format, and downstream usage in one short paragraph.

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-only tool, the description is complete: it states what is returned, in what format, and how the result should be used. No output schema is provided, but the CSV format is explicitly described.

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 property description fully explains that 'report' is the name of a Microsoft Ads report and one of the available report names, linking conceptually to the reports list tool. This adds enough context beyond the raw parameter name.

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

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

The description clearly states the tool gets selectable columns for a Microsoft Ads report, specifies CSV output format (one per row), and explains their purpose as valid entries for the report query's 'columns' argument. This distinguishes it from sibling tools like ms_ads_reports_list and ms_ads_execute_report_query.

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 should be used to discover valid column names before constructing a report query's 'columns' argument. It does not explicitly mention alternatives or when not to use it, but the reference to the query's columns argument gives clear practical 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds valuable context about the CSV format and the meaning of the 'Type' column, including that the two types use different naming conventions. This goes beyond annotations and helps the agent interpret the output correctly.

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 output format, then explains the two types. Every sentence earns its place; no wasted words. It is concise and well-structured.

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

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

For a listing tool with no parameters and no output schema, the description covers everything an agent needs: it specifies the CSV format, the columns, and the meaning of the two types, including the note about naming differences. No critical information is missing.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. With no parameters to document, the description does not need to add anything. The baseline for zero parameters is 4, and the description correctly focuses on output semantics rather than parameters.

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

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

The description states a specific verb ('Get') and resource ('available Microsoft Ads reports') and defines the output as CSV with two named columns. It further distinguishes the two report types ('Report' vs 'Bulk') with their meanings, clearly differentiating from sibling tools like ms_ads_report_columns (which lists columns) and ms_ads_execute_report_query (which executes queries).

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

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

The description gives clear context about what the tool returns and the semantics of the two types, which helps an agent decide when to use it. However, it does not explicitly mention alternatives or when not to use it. The distinction between listing reports and executing them is implied but not stated, so a small gap remains.

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 adds useful behavioral context beyond the read-only annotation: it specifies the output format (JSONL), the row structure (one per campaign per date range), and the meaning of the DateRange column. Since annotations already indicate read-only and non-destructive behavior, the additional detail is appropriately supplementary.

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 redundancy. The main purpose is front-loaded, followed by precise identification details and output semantics. Every clause adds value; no filler or unnecessary 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 tool with five parameters and no output schema, the description gives sufficient context: purpose, identification method, output format, row granularity, DateRange meaning, and filtering option. It does not enumerate possible output fields, but that is not essential for invoking the tool correctly.

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

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

Schema coverage is 100% with each parameter already described. The description restates where PerfmonId and PerfmonDefinitionMetricId come from (matching schema text) and clarifies the campaignIds filter, but these are marginal additions. The primary new information (DateRange) pertains to the output, not parameters. Baseline of 3 is appropriate given 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?

Clearly states the action ('Get') and the resource ('per-campaign metric rows behind a triggered perfmon alert'), specifying the output format (JSONL). Distinguishes from sibling alert-view tools by indicating this returns the underlying rows, not the alert definitions.

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

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

Provides explicit instructions on how to identify the alert (PerfmonId, PerfmonDefinitionMetricId, accountId) and how to filter (campaignIds). Explains the DateRange semantics for interpreting rows. While it doesn't explicitly contrast with sibling tools, the context of sibling names (perfmon_fluctuation_alert, perfmon_threshold_alert) makes the use case 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?

The readOnlyHint annotation already covers side-effect expectations, and the description adds useful context by stating that no history is kept and that the result is the current state. There is no contradiction between the description and 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 verbose, with a long enumeration of output fields and repeated emphasis on default priority behavior. The field list is valuable because there is no output schema, but the text could be tightened without losing important 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?

There is no output schema, so the description compensates by enumerating the fields carried in each JSONL line and explaining priority, filtering, and current-state semantics. It is reasonably complete for the tool's read-only nature.

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

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

All parameters have detailed schema descriptions, including accountIds filtering, campaignIds scoping behavior, and minPriority values with defaults. The description largely repeats or restates this information rather than adding substantial new meaning, 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 clearly states the tool's purpose: getting currently triggered perfmon fluctuation alerts for one or more accounts as JSONL. It also distinguishes this from threshold alerts through the explicit 'FLUCTUATION' qualifier and the detailed alert semantics.

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

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

It explains that the tool returns current state because perfmon keeps no history, and it specifies the default priority behavior. It does not explicitly contrast with the sibling perfmon_threshold_alert tool, but the fluctuation framing makes the intended use 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 description discloses behavioral traits beyond the annotations: it notes that no history is kept (current state only), describes the output format (JSONL), and explains the default priority filter. These details provide transparency about what the tool returns and its limitations, though it does not mention potential errors or edge cases like empty results.

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, dense sentence that lists many output fields. While it is long, all information is relevant and there is no redundancy. The structure is slightly monolithic but acceptable given the lack of an output schema; it could be improved with bullet points, but it remains clear and focused.

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

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

Without an output schema, the description fully specifies the returned fields and their meanings (e.g., Metric, AlertLevel, Priority). It also explains the default behavior of minPriority and the effect of omitting parameters. This gives an agent all necessary context to invoke the tool correctly and interpret 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?

The input schema already provides comprehensive descriptions for all three parameters, covering their purpose, defaults, and acceptable values. The tool description repeats none of this information and adds no further parameter semantics. Since schema coverage is 100%, the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'Get', the resource 'perfmon THRESHOLD alerts', and the scope 'for one or more accounts'. It also mentions the output format 'JSONL' and distinguishes from historical data by noting 'Perfmon keeps no history'. This makes the tool's purpose unambiguous and distinct from siblings like perfmon_alert_output_table or perfmon_fluctuation_alert.

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

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

The description provides usage guidance for parameters, such as 'Use this ONLY to focus on / analyze specific campaign(s)' for campaignIds and explains the default behavior of minPriority. It indirectly implies when to use this tool (current state only) by mentioning 'no history', but it does not explicitly name alternative tools or state when not to use it. This is clear enough for most scenarios.

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

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

The readOnlyHint and destructiveHint annotations already cover the non-mutating behavior, and the description consistently describes a read operation. It adds useful output-format context but no conflicting behavior.

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

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

The description is compact but information-dense, using two sentences to convey purpose, scope, output format, target categories, and included fields. No unnecessary 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?

With no output schema, the description compensates by listing the fields contained in each line. It lacks details on error conditions or ordering, but for a simple read-only getter it is sufficiently 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 only parameter, accountIds, is fully described in the schema with its optionality, meaning, source of valid values, and default behavior when omitted. No ambiguity remains.

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 retrieves current active pacing and efficiency targets as JSONL, and explicitly distinguishes the scope from budget-only targets. The resource and purpose are 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?

Describes what the tool covers and that it returns active targets, but does not explicitly compare it to sibling tools such as target_pacing_all or state when one should be preferred over the other.

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 indicate read-only and non-destructive behavior, and the description reinforces this by describing a listing/retrieval operation returning JSONL. It also clarifies date-scope behavior, which adds transparency 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 compact and well-structured, front-loading the core purpose and then clarifying scope and limitations. No redundant or filler content.

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

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

Sufficiently complete for a read-only listing tool: it explains output format, coverage, and date restriction. It does not describe a return schema, but none is provided, and the operation is simple enough that this is not a critical 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?

The single parameter accountIds is fully described in the schema including default and omission behavior. The description reinforces that omitting returns all accounts, adding practical meaning beyond the schema text.

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 gets all pacing and efficiency targets as JSONL, explicitly covering Pacing and Efficiency types. It distinguishes itself from the sibling target_pacing tool by saying 'all' and by describing scope across periods and the 365-day limit.

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

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

Provides useful usage context: not just budget, includes pacing and efficiency targets, limited to last 365 days plus current/future. It implies this is the broader list compared to target_pacing, though it does not explicitly name the sibling alternative or when to choose one over the other.

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 adds useful behavioral details (JSONL format, time limit) without contradicting the annotations. No side effects are mentioned, which is consistent with the read-only nature.

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

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

The description is a single, concise sentence that directly conveys the tool's purpose and key constraints without unnecessary detail.

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 provides enough context for the tool's operation, including output format and time limit. Since there is no output schema, it does not need to explain return values. Minor details like pagination are omitted but not critical for basic usage.

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 only parameter, accountIds, has a full description in the schema, so the tool description does not need to add more. The schema coverage is 100%, meeting the baseline for this dimension.

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', the resource 'tasks', and the output format 'JSONL', which distinguishes it from other tools. It also specifies a time limit, making the purpose 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 provides clear context about the tool's behavior (JSONL output, 365-day limit) but does not explicitly state when to use it versus alternatives. However, since no sibling tool performs a similar task-listing function, the intended use is implicit and 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?

The read-only nature is already covered by annotations, and the description adds behavioral context by specifying JSONL output and the 'no account restriction' scoping. It does not mention pagination or rate limits, but those are not required 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?

The description is brief, but the phrase 'returns rows only for a connector with no account restriction' is vague and confusing. It introduces ambiguity without adding clear value, so not every sentence earns its place.

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

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

The tool is simple, but the contradictory statements about account filtering leave the overall behavior unclear. The description would be complete if it clarified whether accountIds is accepted and how it affects results; without that, it is not reliable.

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 accountIds as an optional filter, but the description explicitly says the data is 'not account-filterable'. This directly contradicts the parameter's purpose and undermines the agent's ability to decide whether or how to pass accountIds.

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 resource as the customer's users, the action as getting/listing them, and the output format as JSONL. It also distinguishes it as customer-level data, separating it from account-level tools.

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

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

It states that the data is customer-level and not account-filterable, giving clear scope and exclusions. However, it does not explicitly name an alternative tool such as user_my_accounts, so it falls short of fully explicit alternative 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?

Annotations already indicate read-only, and description adds no extra behavioral details but clarifies output format (JSONL).

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 redundancy, all information relevant.

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

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

Explains the concept of My Accounts, the output format (JSONL, one row per selection), and the optional filter; sufficient despite lack of 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 fully describes accountIds with optionality and meaning; description only repeats the filter behavior, so no additional meaning beyond 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 a specific verb ('Get') and resource ('each user's selected My Accounts'), distinguishes from sibling tools like 'account' and 'user' by clarifying it's a per-user preference, not access-permission.

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

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

Provides context on when to use (when you need user preferences, not permissions) and mentions optional filtering by accountIds, but does not explicitly name alternative tools for comparison.

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