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

With no annotations provided, the description carries the full burden. It explicitly declares the operation is read-only and states what it does and does not read. It also explains that it reports the actual policy topics behind limited/disapproved statuses, going beyond the status word. While it doesn't mention potential pagination or performance limits, the description is transparent about its core behavior and limitations.

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 about 60 words and packs every sentence with distinct value: the first explains the core read scope, the second addresses duplicate headlines, and the third clarifies exclusions and read-only nature. It is efficient and front-loaded, though slightly dense. No filler or tautology.

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 an output schema, so return values are already structured. The description covers the essential info an agent needs: what is read, what is excluded, and the read-only nature. It could mention edge cases like pagination or how omitted filters behave, but the schema covers parameter behavior. Overall it is sufficiently complete for a read tool with a rich output schema.

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

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

Schema description coverage is 100%, so each parameter (adId, adGroup, includeRemoved) already has a clear description. The tool description itself adds no parameter-specific meaning—the details about 'for reading back the copy' and 'answers whether a headline is repeated across ad groups' appear in the schema, not the description. Per the rubric, high schema coverage sets a baseline of 3, and the description does not exceed it.

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 clear verb ('Read') and a specific resource ('what a Google Ads ad actually says'), then enumerates exactly which details it covers (headlines, descriptions, pinning, performance labels, URLs, policy topics). It also explicitly states what it does NOT read (assets like sitelinks), which distinguishes it from the sibling ads_assets. This gives an agent a precise, unambiguous picture of the tool's 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 provides contextual guidance: it notes that duplicate headlines are reported because they indicate poor A/B testing, and it clarifies that assets are not covered (implying use ads_assets for those). It also labels itself 'read-only', steering away from update tools. However, it does not explicitly name alternative tools such as ads_ads or ads_assets, so an agent would need to infer the comparison from the sibling list rather than being directly told when to use each.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It states 'read-only', making clear it has no mutation effects. It also lists the types of data returned, but does not explain what happens if no ad data exists, whether authentication is required, or any pagination limits. This is adequate for a simple read tool but lacks depth.

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

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

The description is a single, efficient sentence that front-loads the action and read-only nature, then lists the specific fields returned. There is no wasted wording, and it conveys the core purpose succinctly.

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 a simple one-parameter tool with an existing output schema, the description adequately covers what data the tool retrieves and its read-only nature. It could mention the default date range or clarify that it returns a list of ads, but these are minor gaps given the schema covers the parameter details and the output schema handles return structure.

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

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

The input schema fully documents the 'days' parameter with a clear description of its purpose and constraints. The tool description does not mention the parameter at all, but since schema coverage is 100%, the baseline of 3 applies without any additional semantic value added.

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 ('Read'), the resource ('Google Ads ads'), and the specific data points ('ad strength, policy approval status, serving status and metrics'). It explicitly marks the operation as read-only and distinguishes itself from sibling tools like ads_campaigns and ads_keywords by focusing on the ad level with these specific attributes.

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

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

The description implies that this tool is for retrieving ad-level details with the listed fields, which differentiates it from sibling tools. However, it does not explicitly state when to prefer this over others or provide exclusions, though the specific fields give clear context for its intended use.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It explicitly notes the tool is read-only, that account-level assets are included even when a campaign is specified, that 'Attached is not shown', and that unreadable levels are reported as errors. These disclosures go well beyond typical descriptions and cover key behavioral nuances.

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 three well-crafted sentences, with the primary purpose front-loaded. Each sentence adds distinct value: the main read operation, the account-level nuance with a practical example, and behavioral caveats plus the read-only note. There is no redundant or filler text.

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

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

Given the tool's complexity (multiple asset types, multiple levels, filtering) and the presence of an output schema (which covers return values), the description is complete. It explains filtering behavior, error handling, and the relationship to ad copy, giving an agent everything needed to call it correctly without requiring external knowledge.

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?

Although the schema already documents all parameters (100% coverage), the description adds significant semantic value. For 'type', it notes that omitting it lists all types including those without shaped readings; for 'campaign', it clarifies that account-level assets are still listed; for 'includeRemoved', it explains the rationale for the default. This enriches each parameter's meaning beyond the basic 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?

The description states a specific verb ('Read') with a clear resource ('sitelinks, callouts, structured snippets, promotions, prices, call and image assets') and scope ('account, campaigns, ad groups'). It further specifies that it returns actual content rather than just type/id, which distinguishes it from sibling tools like ads_ad_copy. This is a precise, non-tautological 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 provides clear context on when to use this tool, notably the example that an ad looking bare in ads_ad_copy may be serving with assets from this tool. It implicitly differentiates from ads_ad_copy by emphasizing asset content. However, it does not explicitly name alternatives or state when not to use this tool, so it falls short of a 5.

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

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

No annotations are present, so the description carries the burden. It explicitly discloses read-only behavior and the required credentials (developer token, OAuth client, refresh token), which are the key behavioral and operational facts. It does not discuss pagination or rate limits, but these are not necessary for a simple read with an output 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 sentence that packs the resource, metrics, time scope, and auth requirements with no filler. Essential information is front-loaded.

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

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

For a one-parameter read-only tool with a full output schema, the description plus schema cover the operation, auth, safety profile, and parameter semantics. 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?

The only parameter, days, is already fully described in the schema (default, min, max, meaning). The description's 'over a window' adds no new semantic detail, so with 100% schema coverage 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?

States a specific verb ('Read'), a specific resource ('Google Ads campaigns'), and enumerates the exact metrics returned (status, daily budget, impressions, clicks, cost, conversions) over a time window. This clearly distinguishes it from sibling ads_* tools that target keywords, ads, ad copy, or assets.

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 clear context: this is the tool for campaign-level Google Ads performance data over a window, and it lists the required auth setup. However, it does not explicitly name alternatives or state when not to use it, so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it declares read-only, states Google's 30-day and 10,000-row retention limits, and warns that empty results over longer windows are limits rather than findings. It also discloses the filtering quirk about resourceType vs. changed field names, which an agent could not infer from the schema alone.

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

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

Three sentences, each earning its place: purpose and content, retention-limit caveat, and filtering guidance. The most important information is front-loaded, and the read-only note closes it without redundancy.

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

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

For a tool with two self-describing parameters and an output schema, the description covers purpose, scope, behavioral limits, filtering semantics, and sibling relationship. Nothing an agent needs in order to decide when and how to call this tool 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 describes both parameters with 100% coverage, so the baseline is 3. The description adds meaningful value beyond the schema by explaining how the days parameter interacts with Google's retention limit and by clarifying the correct filtering approach (resourceType, not changed field names) even though those details are not directly schema properties.

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 ('Read the Google Ads change history') and details what the history contains: what changed, when, fields, by whom, and source. It distinguishes itself from sibling data tools by explicitly positioning itself as the audit trail for ads_update writes, so an agent can tell it apart from ads_campaigns or ads_keywords.

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

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

The description makes the intended use clear: consult this tool when you need the change/audit history rather than the current state, and it explicitly notes it is the audit trail for anything ads_update writes. It gives practical guidance on interpreting empty results over long windows and how to filter. It does not explicitly name alternatives to use instead for current data, but the context 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?

No annotations are provided, so the description carries the full burden. It discloses several behavioral traits: duplicate checking (including removed keywords), account-copy guard, match-type consequences (EXACT vs PHRASE/BROAD buying more), default dry-run behavior, and read-back after creation. These are significant operational details beyond what the schema reveals (e.g., dryRun default). No contradictions with annotations since none are present.

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

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

The description is compact yet dense, with every sentence contributing new operational insight. It front-loads the core action, then layers guard logic and defaults. No fluff or repetition; a model agent can quickly grasp the essential behavior and the reasons behind it. The multi-sentence structure is justified by the complexity of the tool's safeguards.

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

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

Given the tool's complexity (6 parameters, guard mechanisms, dry-run semantics), the description covers all necessary details: what happens on create, how duplicates and copies are handled, match-type trade-offs, dry-run default, confirmation requirement, and post-readback. The output schema is present, so return format is documented elsewhere. No major gaps remain for an agent to invoke 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 coverage is 100% meaning all six parameters have descriptions. However, the description adds context beyond the schema: it explains the guard logic for duplicate keywords (relates to 'keyword' and 'adGroup'), the reason EXACT is default, and the implications of matchType. It also clarifies the bid ceiling check rationale. While the schema already documents parameters, the description enriches the semantics, especially for behaviorally relevant fields like dryRun and confirm. Slight deduct for not adding explanation to the existing param descriptions, but the integration is strong.

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 leads with a clear, specific verb and resource: 'Add one keyword to an ad group.' It immediately differentiates this tool from siblings by stating it is 'the only tool here that creates rather than changes,' which disambiguates it from ads_update and ads_negatives_update. The phrase 'guarded differently' further signals unique behavior.

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 when to use this tool ('Add one keyword') and contrasts it with other tools ('only tool here that creates rather than changes'). It also explains when not to use it indirectly: the duplicate and copy guards define constraints on when the tool will succeed. The dry-run behavior and confirm parameter provide a clear usage workflow, effectively guiding when to invoke with dryRun=false.

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

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

With no annotations present, the description carries the full behavioral burden and does well: it explicitly declares 'read-only' and discloses the non-paginated 'returns every row' behavior. It also hints at why counts from this tool differ from console counts, which is useful operational context. It stops short of discussing auth needs or rate limits, but those are not critical for this read-oriented tool.

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

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

Two sentence-length clauses with zero filler: the first states the resource and fields, the second explains the key behavioral difference from a console count. The 'read-only' safety hint is included without extra 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?

Given the presence of an output schema, two optional parameters, and a clear behavioral description, the tool definition is nearly complete. It explains return scale, read-only nature, and the status-omission behavior via schema. The only gap is the lack of explicit sibling routing, which is already penalized under usage guidelines.

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 itself adds nothing about the two parameters (days and status) beyond what the schema already documents. The schema descriptions are rich, particularly the status parameter's explanation of omitted-state behavior, so no additional compensation is needed.

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

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

The description states a specific verb ('Read') and resource ('every Google Ads keyword'), and enumerates the returned data (effective CPC bid, approval and serving status, metrics). The 'Returns every row rather than a first page' clause distinguishes this from sibling tools like ads_query or ads_campaigns by highlighting the full-fetch behavior.

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

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

The description implies when to use the tool: when you need the complete keyword set and an accurate count, noting that console counts omit rows. However, it does not explicitly name alternative tools or state conditions for choosing this tool over siblings like ads_query or ads_search_terms, leaving the routing largely implicit.

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

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

With no annotations provided, the description carries the full burden of disclosing safety and behavior. It explicitly says 'read-only' and explains that a negative blocks traffic without leaving a record—important context that influences how the agent interprets search results. This goes beyond the schema and adds meaningful behavioral insight.

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 zero fluff. The core purpose is stated first, followed by practical usage guidance. Every clause earns its place—no redundant phrasing or boilerplate.

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 that an output schema exists, the return format is already covered. The description fully explains what the tool does, when to use it, and the nuances of the parameter. It is complete for an agent to decide when and how to invoke it, with nothing critical missing.

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

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

The schema already documents the 'level' parameter with a 100% description coverage, including its enum values. The description adds extra semantic context about the scoping behavior (campaign-level blocks apply everywhere in the campaign; shared sets apply to all attached campaigns), which enriches understanding beyond the raw schema. Since schema coverage is complete, a 4 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: read negative keywords at campaign, ad group, or shared-set level. It distinguishes itself from siblings like ads_negatives_update (which implies write) by explicitly noting this is a read-only check, and it is unambiguous about what resource it operates on.

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

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

It gives explicit when-to-use scenarios: check when a keyword stops serving with no apparent cause, and check before adding a term twice to avoid duplication. These are concrete triggers that guide the agent toward this tool over alternatives. It also states the read-only nature, which helps the agent avoid using a mutating tool by mistake.

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

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

With no annotations provided, the description carries the full burden of disclosure and does so excellently. It reveals the dry-run default, the guard that refuses the batch if a negative would block traffic, the rationale (silent traffic loss), and that terms are read back. It also clarifies the consequence of a wrong negative, which is critical 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?

The description is two sentences with no wasted words. It front-loads the core purpose, then immediately provides the most important behavioral guard, and finishes with dry-run and read-back behavior. Every clause earns its place and the density is appropriate for the complexity.

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 complex 7-parameter tool with no annotations and an output schema, the description covers most key behavioral nuances: guard, dry-run, read-back, and the enumerated-list constraint. The notable gap is that it says the batch is 'refused if one would block traffic' without mentioning that confirm can override the guard, which is a significant behavioral path. The schema covers confirm, but the description's narrative is slightly incomplete on that interaction.

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

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

Schema coverage is 100%, so the baseline is 3, and the description adds meaningful operational meaning to several parameters: keywords are explicitly enumerated with no pattern form, dryRun's default behavior is stated, and the guard logic clarifies action and confirm's context. It does not systematically walk through each parameter but enhances the schema descriptions with non-obvious implications.

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-resource pair ('Add or remove negative keywords in a batch') and adds a distinguishing constraint ('enumerated one by one with no pattern form'). It clearly differentiates from siblings like ads_negatives (which likely reads negatives) and ads_keyword_create (single keyword creation), so an agent can tell it apart without opening schemas.

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 (batch operations, no patterns) but never explicitly says when to use this tool over alternatives like ads_update_batch or ads_keyword_create. It does not name any sibling or exclusion condition, leaving the agent to infer the appropriate choice from the name and purpose alone.

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

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

With no annotations provided, the description carries full behavioral disclosure. It explicitly states that GAQL has no statement other than SELECT and therefore the operation cannot change anything, establishing it as read-only. It does not mention rate limits, query timeouts, or result-size limits, but the core safety behavior is transparently disclosed.

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

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

Two short sentences deliver the purpose, the usage context, and the read-only guarantee with no filler. The information is front-loaded and every clause earns its place.

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

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

Given a single parameter, an output schema, and the explicit read-only guarantee, the description covers what an agent needs to invoke the tool correctly. It could name a few shaped-read siblings to make the fallback role more concrete, but the generic reference is sufficient for routing.

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

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

Schema coverage is 100%, so the schema already documents the single query parameter as a GAQL SELECT statement. The description reinforces the GAQL semantics and the read-only property, but adds little beyond what the schema provides, 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?

Description states a specific verb ('Run'), a specific resource ('Google Ads account'), and the exact mechanism ('arbitrary GAQL SELECT'). It also positions the tool as the fallback for questions the shaped reads do not cover, clearly distinguishing it from the many ads_* sibling reads.

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 a question the shaped reads do not cover' gives clear guidance on when to use this tool as the general-purpose fallback versus the more targeted shaped reads. It does not name specific siblings or give explicit negative examples, but the context is clear enough for an agent to route correctly.

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

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

No annotations are present, so the description carries the full burden. It explicitly states 'read-only' and discloses an important data behavior: 'Google withholds terms too few people searched, so an absent term is unknown rather than absent'. This adds meaningful context beyond the tool name. It does not mention authentication, rate limits, or pagination, but the output schema covers return format, so this is sufficient.

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

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

The description is two sentences with no filler. The core purpose and the key behavioral caveat are front-loaded, and the read-only note is appended efficiently. Every sentence earns its place.

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

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

For a read-only tool with a clear output schema and four optional parameters, the description covers the essential context: what data it returns, the comparison to organic queries, and the data withholding nuance. It doesn't explain prerequisites like authentication or campaign selection, but these are likely common across the toolset and not critical for this simple read 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 coverage is 100% and each parameter has a descriptive explanation (e.g., 'Drop search terms below this many impressions'). The main description does not add additional meaning about parameters beyond what the schema already provides, so it meets the baseline but does not exceed it.

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 ('Read') and identifies the exact resource ('queries that actually triggered an ad') and the data returned (keyword and metrics). It also distinguishes itself from the organic equivalent by calling itself the 'paid equivalent of the Search Console query dimension', which helps an agent separate it from sibling tools like search_analytics. This is a clear, specific purpose statement.

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 a useful comparison to Search Console but does not explicitly name alternative tools or state when not to use this one. It implies this is for paid search queries, but an agent would need to infer that organic queries belong elsewhere. There is no explicit routing to sibling tools like ads_keywords or search_analytics, leaving some ambiguity.

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

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

With no annotations provided, the description carries full burden of behavioral disclosure. It explicitly states the tool spends money, defaults to a dry run, requires confirm to override guards, and re-reads values after writing because an accepted request may not be a stored value. It also enumerates the guard conditions, making the behavior fully transparent.

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

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

The description is dense and covers multiple aspects, but it is not excessively long. It front-loads the purpose and then explains nuanced behaviors. While it could be structured more clearly with separate sentences for each behavioral note, it remains concise enough and each clause adds value.

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

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

The description is comprehensive for a tool with this complexity. It covers the dry run behavior, guard conditions, confirmation requirement, and the distinction between bid and status changes. Since an output schema exists, the description need not explain return values, and nothing critical is missing for an agent to call this 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 description coverage is 100%, so parameters are well-documented. The description adds meaningful context beyond the schema, explaining the relationship between bid and status, and the semantics of dryRun and confirm. It clarifies that dryRun is on by default and why, which is not evident from the schema alone.

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: changing one specific ads entity (bid, budget, status). It also distinguishes between changing a bid and pausing a keyword, which differentiates it from sibling tools that might do similar actions. The resource is specified exactly.

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 (for single changes) and clarifies that pausing a keyword is distinct from lowering its bid. However, it does not explicitly name alternative tools like ads_update_batch or ads_negatives_update, leaving the when-not-to-use guidance implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses dry-run behavior, atomic refusal when an entry matches zero or many rows, per-entry and summed spend guards, and read-back verification after writing. These are critical behavioral details that go well beyond what the schema alone reveals.

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, front-loaded with the main purpose, and each sentence adds a distinct behavioral guarantee. Nothing is redundant or filler; the length is appropriate for the tool's complexity.

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 guarded batch mutation tool with a complex failure model, the description covers the essential invocation constraints, safety behavior, and post-write verification. The output schema handles return-value documentation, so the description is sufficiently complete for an agent to call 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 already has rich descriptions for all four parameters, so the baseline is 3. The description reinforces key meanings, such as the kind restriction and the named-pair form of changes, but it does not add substantial semantic detail beyond the schema's own parameter documentation.

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 starts with a specific verb and resource: changing several Google Ads keyword bids or campaign daily budgets in one call. It clearly distinguishes this batch tool from a rule-based or singular update, making the tool's scope immediately recognizable relative to siblings like ads_update.

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 clearly implies when to use the tool: when updating multiple named targets in one call. It describes the intended shape as an explicit list of pairs rather than a broad rule, which guides appropriate invocation. It does not explicitly name alternative sibling tools, but the context is sufficient for an agent to decide when this batch operation is appropriate.

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

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

Since annotations are absent, the description carries full behavioral burden. It explicitly states read-only and explains that unavailable resources are reported as unavailable rather than empty, which is a key behavioral nuance beyond typical read operations. This is valuable transparency.

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, front-loaded with the core purpose, and every sentence contributes. It efficiently lists surfaces and key behaviors without fluff. The read-only note is placed at the end, which is appropriate as a secondary 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?

Given the high schema coverage and presence of an output schema, the description is quite complete. It covers the behavior on missing resources and confirms read-only. Potential gaps like pagination or error handling are insufficient to call it incomplete for a read-only tool with comprehensive schema.

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

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

The schema covers 100% of parameters, so baseline 3 applies. The description doesn't add much beyond what the schema already describes, but it does mention 'territory availability' which aligns with the availability enum. No additional depth is provided, but it's sufficient given the schema's completeness.

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 lists the specific surfaces (search keywords, tags, experiments, etc.), indicating the verb 'read' and the resource 'App Store discovery surfaces'. It clearly differentiates from siblings like app_store_listing or app_store_reviews by focusing on non-listing data.

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 implies when to use via the surface enumeration, but does not explicitly state when not to use compared to app_store_listing or app_store_reviews. However, the targeted 'beyond the listing text' gives context. Sibling alternatives like app_store_reviews are evident, but no explicit exclusion is made.

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

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

With no annotations, the description carries the full burden and explicitly labels the operation read-only. It also discloses the unusual ratings source (public storefront lookup because App Store Connect exposes no aggregate rating) and that each entry names its source, which is genuinely 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?

Three sentences with no filler, opening with the core operation and then covering ratings provenance and auth requirements. Every sentence carries operational information and the most important detail is front-loaded.

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

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

For a read-only tool with a full output schema and 100% parameter coverage, the description supplies purpose, behavior, authentication, and data provenance. Nothing needed to invoke it correctly is missing, and the output schema covers return-value expectations.

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

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

All five parameters have detailed schema descriptions, so the baseline is 3. The description adds contextual meaning by tying name/subtitle/keywords to Apple's character limits and explaining why storefronts are used for ratings, but it does not map or extend individual parameter semantics beyond the schema.

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

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

The description names a specific verb (Read) and a concrete resource (App Store listing's indexed fields per locale, promotional text, version state, star ratings), which clearly distinguishes it from siblings like app_store_reviews or app_store_discovery. It also adds the meaningful constraint of checking against Apple's character limits.

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 its use through the list of read operations but never states when to choose it over alternatives or when not to use it. The auth-key requirement is operational context, not usage guidance. An agent would have to infer the appropriate context from the tool name and description alone.

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

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

The description discloses a key behavioral trait: the reported mean and star split are computed from the fetched reviews, not the app's lifetime rating, and that App Store Connect exposes no aggregate rating resource. This is valuable context beyond the schema. However, it does not mention pagination behavior, rate limits, or whether responses are included by default, which are minor gaps given the schema already documents pagination parameters.

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

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

The description is two sentences with no wasted words. It front-loads the core action and resource, then adds the critical caveat about the aggregate rating. 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 description is complete for a read-only review-fetching tool. It explains the key caveat about the aggregate rating, and the schema covers all parameters. It could mention whether responses are included by default or how pagination works, but the schema's maxPages and limit parameters already imply pagination. The output schema exists, so return values need not be 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?

Schema description coverage is 100%, so the schema already documents all 7 parameters. The description adds context about the meaning of the returned aggregate (mean and star split) but does not add new parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Read'), a specific resource ('App Store customer reviews and your responses'), and explicit filtering dimensions ('by rating or storefront'). It also distinguishes itself from a potential confusion by clarifying that the reported mean/split is not the app's lifetime rating, which is a meaningful differentiator from other app-related 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 clearly implies when to use this tool: when you need App Store reviews or responses, optionally filtered by rating or storefront. It does not explicitly name alternative tools or state when not to use it, but the context of sibling tools (e.g., app_store_sales, play_store_stats) makes the use case reasonably clear. The clarification about the aggregate rating resource also helps set expectations.

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

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

With no annotations, the description carries the full burden and does well: it explicitly states the operation is read-only, lists required credentials and role permissions, and discloses the no-sales absence behavior. It could go further with rate limits or response shape expectations, but the output schema covers the latter.

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

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

Three sentences deliver purpose, prerequisites, and an edge case with zero filler. The most important information is front-loaded in the first sentence, and every sentence earns its place.

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

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

For a six-parameter tool with a full output schema, the description covers purpose, authentication, role requirements, read-only behavior, and a notable edge case. It is nearly complete, though it stops short of guiding the agent on when to choose this sibling over other app store tools.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters with defaults and formats. The description adds contextual meaning about the report contents, but does not provide parameter-level guidance beyond what the schema already offers.

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 'Read App Store Sales and Trends' and specifies the exact data granularity ('units downloaded per day per territory per app, summarized by SKU'). This clearly distinguishes it from Play Store and other app store sibling tools, even without naming them.

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

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

The description implies usage context by stating it reads App Store Sales and Trends, and it provides credential prerequisites. However, it does not explicitly say when to prefer this tool over alternatives such as play_store_stats or app_store_listing, nor does it list any exclusion conditions.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool audits up to N pages, aggregates issues, requires only a sitemap URL, and does not need Google credentials. It does not mention potential side effects or rate limiting, but 'audit' implies a read-only operation and the key behavioral constraints are clearly stated.

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 compact sentences deliver the core purpose, the input requirement, and the authentication context without any filler. Key constraints are front-loaded, and the sentence structure makes the tool's scope immediately clear.

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 3-parameter schema, high schema coverage, and the presence of an output schema, the description is sufficiently complete for an agent to select and invoke the tool. It explains the input type, scope, aggregation behavior, and auth requirement; the remaining details, such as concurrency defaults, are already present in the structured schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds marginal value by linking 'up to N pages' to maxPages and confirming sitemapUrl is the input, but it does not explain concurrency or add meaningful detail beyond what the schema already 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 uses a specific verb ('Audit') and names the exact resource ('on-page SEO of up to N pages from a sitemap'), then clarifies the output ('roll up the most common issues'). It also distinguishes itself from Search Console-based tools by explicitly stating it takes a sitemap URL and needs no Google credentials.

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 usage context: use it when you have a public sitemap and want a site-wide rollup of common on-page SEO issues. It implies an alternative path ('rather than a Search Console property') but does not explicitly name a sibling tool or state when not to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does convey the key non-obvious behavior of comparing against the preceding equal-length period, and 'compare' implies a non-mutating read operation. However, it does not explicitly state that the tool is read-only, nor mention any rate limits, required permissions, or other 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?

A single, front-loaded sentence with no filler. Every word contributes to understanding the tool's core behavior and output. Length is appropriate for the tool's complexity.

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?

Description is adequate given that an output schema exists and all parameters are documented. However, it does not clarify how gainers/losers are computed or what metric drives the comparison, and it relies on the user to infer the default 28-day window behavior from the schema. Sufficient for invocation, but not rich.

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 no parameter-specific meaning beyond what the schema already documents; it only frames the overall use case (comparing windows to find gainers/losers), which is already implied by the parameter descriptions.

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 ('Compare') with a clear resource ('an analysis window with the preceding equal period') and states the intended output ('identify search gainers and losers'). This distinguishes it from raw analytics tools like search_analytics, though it does not explicitly name any sibling or contrast itself with 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 the tool is useful (when you need period-over-period gainers/losers) but provides no explicit guidance on when to use it over alternatives such as search_analytics, ctr_gaps, or compare_snapshots. No exclusions, prerequisites, or routing cues are given.

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 explicitly states 'Reports arithmetic only, never whether a change was good or what caused it; read-only'. This goes beyond the schema and annotations (which are absent) by disclosing the tool's interpretive limits and safety profile. It tells the agent the tool will not provide causal or evaluative analysis, which is valuable behavioral context. It could add more about output format or error cases, but the core behavioral traits are 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 two sentences with no wasted words. The core action and compared fields are front-loaded, and the behavioral caveat ('arithmetic only... read-only') is placed at the end where it supplements rather than obscures the main purpose. 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 has an output schema, so return values are already structured. The description covers the tool's purpose, scope, and behavioral limits. It doesn't mention edge cases like what happens if a snapshot doesn't exist or if from/to are the same, but the schema's parameter descriptions and the output schema reduce the need for that. For a read-only comparison tool, this is nearly 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?

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly, including the special values 'latest' and 'previous' for from/to and the default/min/max for minImpressions. The description adds the list of compared fields, which gives context for what the parameters affect, but it doesn't add new parameter-level semantics beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Compare'), a specific resource ('two snapshot documents'), and the exact fields compared ('clicks, impressions, positions, installs, ratings and locale counts'). It also distinguishes itself from siblings by focusing on snapshot comparison, which is unique among the listed tools. The scope is clear and an agent can select it without opening the schema.

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 comparing two snapshots and needing arithmetic differences. It does not explicitly name alternatives or exclusions, but the sibling list contains related tools like compare_search_periods and list_snapshots, and the description's focus on snapshots makes the usage context clear. It lacks an explicit 'use X instead when...' statement, so it doesn't earn a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool is read-only, requires a specific API key, and returns the current 28-day field record with p75s and histograms. It also notes the PageSpeed field block is being discontinued, which is useful context. It doesn't detail error behavior or rate limits, but the read-only and data-scope disclosure is solid.