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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states the operation is read-only, does not create or edit keywords, and is a Keyword Planner RPC. It also discloses the return contents (suggested pairings, normalized text, suggested match type), which is meaningful 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 tightly written sentences with no filler. It front-loads the primary action and immediately states the read-only, non-mutating nature, then lists the return payload. Every sentence adds essential information.

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

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

For a three-parameter tool with no output schema, the description is remarkably complete: it explains the operation, the input context (supplied keywords, existing ad groups), the outputs, and the fact that no changes are made. The schema handles parameter bounds and identity, so nothing critical is missing 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?

The schema describes adGroupIds and customerId but not keywords. The description compensates by clarifying that keywords are supplied text inputs and that the tool organizes them, while also hinting at keyword normalization and match type in the output. This adds useful meaning around the keywords parameter even though the schema does not describe it directly.

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 ('organize') and resource ('supplied keywords into existing Google Ads ad groups'), and clearly names the output: suggested ad group/campaign pairings, normalized keyword text, and suggested match type. It also distinguishes itself from read-only query tools by stating it does not create or edit 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 implies when to use this tool: when you already have keywords and existing ad groups and want them organized. However, it does not explicitly say when not to use it or name alternatives such as google_ads_generate_keyword_ideas, even though sibling tools make those alternatives obvious.

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 disclosure burden and does well: 'read-only planless RPC does not create a campaign or saved plan' plus 'temporary keyword campaign' clearly signals no persistent side effects. It does not cover auth or rate-limit behavior, but the key mutability trait 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 dense sentences with no filler: the first leads with the action and output metrics, the second summarizes supported features and the side-effect disclaimer. The structure front-loads the most decision-relevant information.

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

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

For a complex 18-parameter tool with no annotations and no output schema, the description covers the core purpose, returned metrics, supported options, and side-effect profile. It still lacks explicit guidance on choosing this versus sibling forecast/idea tools and on return-value shape, but the schema fills most parameter detail.

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 56%, so the schema already documents many parameters. The description adds value by grouping capabilities ('targeting, negatives, match type, three bidding strategies, explicit future dates, and an optional independent per-keyword breakdown'), but it does not explain individual parameter semantics or required combinations, modestly supplementing 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 opens with a specific verb and resource: 'Forecast impressions, clicks, CTR, CPC, cost, conversions, and CPA for a temporary keyword campaign.' It lists the exact output metrics and the scope. The 'forecast' framing distinguishes it from historical/idea siblings, and the direct statement that it 'does not create a campaign or saved plan' further separates it from creation-style 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 provides clear context: use this tool for forecasting a temporary keyword campaign, and it explicitly states what it does not do ('does not create a campaign or saved plan'). However, it never names an alternative such as google_ads_generate_keyword_historical_metrics for past-performance needs, so the when-not/alternative guidance is not fully 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: 'read-only planless RPC' explicitly discloses that the call mutates nothing and requires no Keyword Planner plan, and 'computed 3-month and YoY changes' discloses that the server pre-processes data rather than returning only raw series. It does not cover rate limits, permission requirements, or failure behavior, but for a read-only tool the central state-modification question is answered. The read-only disclosure adds context the schema alone could not convey.

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 zero filler: action in sentence one, compact return-value enumeration in sentence two, and the read-only/planless qualification in sentence three. The most selection-relevant information (what it fetches and returns) is front-loaded ahead of the safety classification.

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

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

For a 12-parameter tool with no output schema, the explicit return-value enumeration is the critical missing piece, and the description provides it, naming every output group an agent would want to map to downstream use. The behavior classification (read-only, planless) and the history-length caveat ('up to 48 months', with 24 enabling YoY as stated in the schema) round out the operational picture. It stops short of routing among the three keyword siblings and omits response-size guidance, which the schema's 50,000-point guard only partially covers.

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 83%, with only network (an enum with self-explanatory values) and includeAdultKeywords (a self-describing boolean) lacking descriptions, so the schema already does the heavy lifting. The description's mention of 'close variants' and 'up to 48 months' reinforces the keywords and historyMonths parameters but adds no new syntax or format details. Baseline 3 is correct because the description adds marginal value over an already well-documented 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 and resource ('Get Keyword Planner search-volume history') and enumerates the exact return payload (average monthly searches, monthly volumes up to 48 months, latest volume, 3-month/YoY changes, competition, CPC/bid ranges, close variants, device totals). This clearly distinguishes it from sibling keyword tools: generate_keyword_ideas produces candidate keywords and generate_keyword_forecast_metrics produces future projections, while this one retrieves historical volume. The 'read-only planless RPC' clause further separates it from the GAQL and run_readonly_rpc siblings.

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 tool's scope clear (historical search-volume data, not ideas or forecasts) so an agent can infer when to choose it, but it never names an alternative or states an exclusion. With close siblings like google_ads_generate_keyword_ideas and google_ads_generate_keyword_forecast_metrics, explicit 'use this for historical data, that for future estimates' routing would materially improve selection accuracy. As written, usage guidance is implied rather than stated.

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

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

With no annotations, the description carries the behavioral disclosure burden and does well: it states 'Read-only; no plan is saved,' lists returned data categories, and mentions pagination. It does not cover API authorization or usage limits, but the core safety and output behavior are 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 three tight sentences with no filler. It front-loads the main action and input options, then efficiently lists outputs and the key read-only guarantee.

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 16-parameter tool with no output schema and no annotations, the description covers the most important call-shaping facts: valid seed inputs, returned fields, pagination, and safety. It could go further on parameter interplay such as site exclusivity or which options require specific input modes, but the schema already documents several of those constraints, so the overall picture is sufficient.

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

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

Schema description coverage is low at 38%, so the description partly compensates by explaining the main seed modes: up to 20 seed keywords, URL, keywords plus URL, or whole site. It adds meaning around seed-source combinations and pagination, but it does not clarify many other parameters such as network, geoTargetIds, languageId, include toggles, or customerId semantics beyond what the schema already says.

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 and resource (Discover Keyword Planner ideas) and enumerates the exact accepted input modes: up to 20 seed keywords, a URL, keywords plus URL, or a whole site. It also summarizes the returned data, making the tool's purpose immediately distinguishable from siblings like generate_keyword_historical_metrics or forecast_metrics.

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

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

The description implies when to use the tool: when the agent needs keyword ideation from seeds or a domain, and it adds a helpful read-only/no-plan-saved signal. However, it does not explicitly name alternative tools or state when not to use this one, leaving the routing decision partly 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'Get' implies a read-only operation, which is useful, but the description does not specify what 'detailed information' includes, whether special permissions are needed, or how errors are returned.

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

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

The description is one concise sentence with no filler or repetition. It is front-loaded with the action and clearly names the target resource, making it easy for an agent to parse quickly.

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 tool the description is functional, but there is no output schema and the description does not specify what details are returned. This leaves or some ambiguity about the tool's output, though the basic invocation requirements are fully covered.

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 covers 100% of parameter documentation, including the customerId format example ('without dashes'). The description adds no additional parameter meaning beyond what the schema already 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?

The description states a clear verb and resource: 'Get detailed information for a specific Google Ads customer account.' It distinguishes itself from list-oriented siblings like google_ads_list_accounts by emphasizing a specific account, though it does not explicitly name alternatives or contrast with google_ads_get_account_hierarchy.

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 specific Google Ads customer account' implies this should be used when the caller already has a customerId and needs account-level details. However, there is no explicit guidance about when to choose this tool over sibling tools or any exclusions.

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

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

With no annotations provided, the description carries the full burden. It discloses the data source (GAQL customer_client), the scope ('accessible customers'), and an important behavioral detail: it falls back to accessible customers if hierarchy queries are unavailable. This adds meaningful transparency beyond the tool name, though it does not cover permissions or output shape.

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

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

The description is two sentences with no wasted words. The primary purpose is front-loaded, and the fallback behavior is presented as a compact second sentence. Every clause contributes information.

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

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

For a low-complexity tool with 100% schema coverage and no output schema, the description adequately covers purpose, scope, source, and fallback. The likely return content is inferable from 'List accessible customers... relationships.' A small gap is the lack of explicit guidance on when to use this versus the sibling list_accounts 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 fully documented in the input schema with clear descriptions (includeInactive and managerCustomerId), so schema_description_coverage is 100%. The tool description itself adds no additional parameter-level meaning, so the baseline 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 states a specific verb ('List') and resource ('accessible customers and, where possible, manager/client relationships') sourced from GAQL customer_client. It clearly differentiates itself from sibling tools like google_ads_list_accounts by emphasizing the hierarchy/relationship aspect and the fallback 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 hierarchy focus and fallback wording imply this tool is for retrieving account structure, but the description never explicitly tells an agent when to choose this over google_ads_list_accounts or when it is not appropriate. Usage context is present indirectly rather than stated.

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

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

With no annotations, the description must carry disclosure weight. 'List' signals a read-only operation and the optional campaign filter is stated, but it does not mention pagination behavior, how missing statusFilter is treated, or what response shape to expect.

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 conveys the resource, scope, and main optional behavior 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?

This is a simple list operation and the description covers its core purpose, but without an output schema or any mention of filtering defaults/response behavior, the agent is left to infer some operational details. It is adequate but not comprehensive.

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 50%, covering customerId and campaignId. The description loosely reinforces the campaign filter but adds no detail about limit or statusFilter. The enum values and default on limit are self-explanatory enough to keep this adequate but not 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 uses a specific verb ('List'), names the resource ('ad groups'), and scopes it to a Google Ads account with an optional campaign filter. This clearly differentiates it from sibling tools like google_ads_get_campaigns and 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?

The intended use is implied: call this when you need ad groups for an account, optionally narrowed by campaign. However, it gives no explicit guidance about when to prefer this over alternatives like google_ads_run_gaql or how it relates to the large set of sibling getter tools.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully states that metrics are returned only when startDate/endDate are provided, otherwise only structure is returned. It does not disclose read-only guarantees, pagination, or error behavior, but the key conditional behavior is surfaced.

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

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

Two sentences with no wasted words. The resource is named first, and the critical conditional behavior is stated concisely. Every sentence adds value.

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

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

For a straightforward list tool, the description covers the essential behavioral distinction and names the resource. It does not detail the output shape, paging, or auth requirements, but the schema covers the parameters and defaults, so the dscription is sufficiently complete for selection and invocation.

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

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

Schema description coverage is high at 80%, and the schema already documents startDate and endDate as 'for metrics'. The description essentially repeats this conditional relationship without adding new parameter meaning. It does not clarify typeFilter values or limit behavior beyond what the schema provides.

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

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

The description states a specific action on a specific resource: 'List portfolio bidding strategies.' This clearly distinguishes it from sibling tools like google_ads_get_campaigns or google_ads_get_budgets, and the 'portfolio' qualifier adds important 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 clear contextual guidance: use this tool to list portfolio bidding strategies, and include dates if metrics are needed. It does not explicitly name alternatives or when-not-to-use cases, but the scoped resource and conditional date behavior make the intended usage clear among the sibling tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does convey that the operation is a read ('List') and that some fields are conditional ('when supported'), which is useful, but it leaves pagination via the limit parameter, the meaning of 'when supported,' and empty/error behavior unexplained. It adds some value but not rich behavioral context.

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

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

A single front-loaded sentence that states the verb and resource first, then appends the distinguishing field list with no filler. The 'when supported' caveat adds needed nuance without bloating the description.

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 output schema and no annotations, the description is too thin. It omits the meaning of statusFilter, does not explain limit or pagination, and leaves 'when supported' ambiguous, so an agent still cannot invoke it confidently beyond supplying the required customerId.

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 only 33% (only customerId is described), so the description must compensate for limit and statusFilter, but it does not. statusFilter's filtering role and limit's pagination role remain undocumented in both schema and description; the listed fields describe output rows, not input semantics.

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

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

The description uses a specific verb ('List') and a distinct resource ('campaign budgets'), then enumerates the distinguishing return fields ('amount, status, delivery method, and recommended budget fields'). Among siblings such as google_ads_get_campaigns and google_ads_get_bidding_strategies, this is the only tool targeting budgets, so an agent can identify it unambiguously.

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

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

The description provides no guidance on when to use this tool versus alternatives. It contains no exclusions, no reference to sibling tools, and no conditions such as 'use when budget-level data is needed.' Applicability must be inferred entirely from the tool name and the field list.

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

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

With no annotations, the description carries the burden of behavior. 'List' conveys a read-only operation and the listed output fields hint at what is returned, but it does not disclose pagination behavior, the default statusFilter semantics, authentication needs, or whether the result is limited in any way. There is no contradiction, but meaningful behavioral context is missing.

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

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

The description is a single, front-loaded sentence: it names the operation, resource, and key output fields without filler or repetition. Every phrase earns its place.

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

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

For a simple list tool the description is adequate, but there is no output schema to document return shape and the description omits details like pagination, default status behavior, and how it differs from the many sibling reporting tools. Required/optional parameters are covered by the input schema, so the main gaps are behavioral and output-format related.

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 only 33% (only customerId has a description), and the description does not explain limit or statusFilter beyond their names. The phrase 'with status' vaguely relates to the statusFilter, but it mainly describes output fields rather than input parameters, so the description does not compensate for the low schema coverage.

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

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

The description uses a specific verb ('List') with a clear resource ('campaigns') and scope ('for a Google Ads account'), and names the key output fields (status, budget, channel type, bidding strategy). This makes it easily distinguishable from sibling tools like google_ads_get_adgroups or google_ads_get_budgets without needing to open their 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 the tool is for retrieving campaign-level data, but it does not explicitly state when to prefer it over alternatives or mention any exclusions/conditions. There is no 'use this instead of X' guidance, so an agent must infer usage from the title and sibling names.

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 behavioral disclosure burden. It usefully discloses enforced constraints: 30-day date window and LIMIT <= 10000. However, it does not explicitly state read-only status, error behavior, ordering, or permission requirements.

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

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

Two sentences with no filler. The core purpose is front-loaded, and the second sentence adds important API constraint information that justifies 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 fetch tool with seven parameters, the schema handles most parameter documentation, and the description adds the key Google Ads constraints. It does not detail output shape or pagination, but 'Fetch recent change_event rows' adequately communicates the return concept given the context.

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 86%, so the schema already documents most parameters with defaults, formats, and bounds. The description adds the cross-parameter 30-day window constraint that is not fully visible in the schema, but it does not deeply explain filter parameters. 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 and resource: 'Fetch recent change_event rows.' It also names concrete constraints, making it clear this tool is dedicated to Google Ads change events. Among many sibling get_* tools, this uniquely identifies the change-event resource without ambiguity.

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 by resource name and adds useful API constraint context, but it does not explicitly state when to use this tool versus alternatives or when not to use it. No sibling differentiation or exclusion conditions are provided.

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

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

With no annotations, the description carries the behavioral transparency burden. 'List' signals a read-only operation, and the description adds a meaningful caveat with 'when supported' for last activity dates, indicating that some fields may not be available for all conversion action types. It does not detail pagination, rate limits, or authentication, but provides solid field-level behavioral context.

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 entire description is one front-loaded sentence that begins with the action and lists the relevant output fields in a compact sequence. There is no filler, repetition, or extraneous context, so every word earns its place.

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

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

The description identifies the tool's purpose and output fields, which is adequate for basic selection. However, because there is no output schema and no annotations, more detail would help: how statusFilter affects results, what 'when supported' means for specific conversion action types, and whether the list is limited to the customerId account. The schema covers invocation structure but not these behavioral nuances.

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 only 33%, with only customerId documented in the schema. The description does not explain limit or statusFilter semantics at all; 'status' is mentioned as an output field, not as a filter parameter. Since neither the description nor the schema clarifies two of the three parameters, the agent has limited guidance for invoking the tool correctly.

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 clear, specific verb and resource: 'List conversion actions.' It enumerates the key output fields (status, type, category, flags, owner customer, last activity dates), which makes the tool's purpose immediately distinguishable from all sibling getters. No other sibling targets conversion actions, so the resource 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: use this tool when you need conversion actions and their metadata. However, it provides no explicit guidance on when to prefer it over alternatives, nor does it mention any exclusions or complementary tools. The context is clear 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?

With no annotations, the description must carry behavioral disclosure. It does reveal two important behaviors: GAQL is auto-generated and incompatible metric/segment combinations cause query splitting. It does not state expected output shape, whether results are merged across splits, pagination/limit handling, or confirm read-only semantics, so some transparency gaps remain.

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

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

Two tight sentences: purpose first, behavior second, and value references third. No filler or redundancy; every clause contributes.

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 complex (10 params,no output schema,no annotations), so the description needs to cover return format, date semantics, and split-query result handling. It covers auto-generation and splitting at a high level, but an agent still lacks enough detail to predict the response or configure dates/order/limits correctly without opening the schema.

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

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

Schema coverage is high (80%), so the baseline is 3. The description adds real value by pointing to google-ads://metrics and google-ads://dimesions as authoritative sources for valid values, which is helpful given metrics and dimensions are free-form string arrays. It doesn't explain every parameter, but the schema already handles most of them.

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 specifies a concrete action ('Query Google Ads performance insights') and distinctive behaviors ('Auto-generates GAQL', 'handles metric/segment incompatibilities by splitting queries') that separate it from raw-GAQL execution (google_ads_run_gaql) and from fixed-view getters like google_ads_get_campaigns. This is enough for an agent to know what the tool does at a glance.

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: users should call this when they need flexible metric/dimension combinations and don't want to hand-write GAQL, especially when incompatible metrics/segments require splitting. However, it never explicitly states when to prefer this over google_ads_run_gaql or the specialized getters, nor gives exclusions.

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

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

No annotations are present, so the description carries the burden. It signals a read-only operation via 'Get' and names the underlying resource, which is useful. However, it does not disclose output units (e.g., cost in micros), pagination behavior, date-range handling, or ordering, leaving meaningful behavioral gaps.

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

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

Two short sentences, front-loaded with the verb and resource, with no filler. Every sentence adds useful information about what the tool does and returns.

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 no output schema and no annotations, so the description is the only source for return behavior. It lists the main metrics but leaves unspecified units, default date-range semantics, sorting, and how results relate to Google Ads reporting conventions. This is workable for a simple query tool but has clear gaps.

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 describes customerId, startDate, and endDate, covering 75% of parameters. The description adds no extra parameter meaning and does not explain the 'limit' parameter, which relies on its default/min/max in the schema. Overall, it is adequate but not enhanced.

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 action ('Get'), the data source ('keyword_view resource'), and the content (quality score, impressions, clicks, cost), so an agent understands what the tool returns. It does not explicitly differentiate among the large set of sibling Google Ads tools, so it stops short of a 5.

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

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

The description implies use when keyword-level performance data is needed, but it gives no guidance on when to choose this tool over related siblings such as google_ads_get_search_terms, google_ads_run_gaql, or google_ads_generate_keyword_historical_metrics. No exclusions or alternative routing are provided.

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

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

No annotations are supplied, so the description carries the behavioral burden. It does convey that the operation is a read-only fetch and warns that quality metrics are returned only when supported, which is useful. However, it does not describe auth requirements, pagINATION, rate limits, or what happens when certain metrics are not supported. That leaves meaningful gaps.

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 gives the resource, action, and output dimensions with no filler. The 'when supported' caveat is placed at the end, and every clause earns its place. This is appropriately sized for a moderately complex tool.

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

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

The description is enough to make a basic call: it names the core return categories and hints at data availability. Yet with no output schema and no annotations, it does not clarify exact metric names, pagination behavior, how 'unsupported' metrics surface, or how the campaignId filter affects results. The gaps are not fatal but are noticeable for an agent needing robust invocation.

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

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

Schema description coverage is 80%, which meets the high-coverage baseline, so the description does not need to compensate much. The schema already explains customerId, start/endDate, and campaignId, and the description adds no per-param semantics; 'limit' is left to the schema's default/maximum without a description. The final-URL and context phrasing describes output fields, not 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?

Description names a specific resource (landing_page_view), a specific action (Fetch), and the output scope (final URL, campaign/ad group context, traffic, conversion, quality metrics). This clearly separates it from sibling getters like google_ads_get_campaigns or google_ads_get_keyword_performance. It does not explicitly name siblings or scope, so it stops short of a top score.

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?

Usage is implied rather than explicit: the resource and metric terms suggest when it applies, but there is no direct statement of when to use it over alternatives, and no exclusion criteria. 'When supported' is a capability caveat, not a routing instruction. An agent would have to infer its niche among a large list of get_* tools.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It explicitly states the operation is read-only and exposes an important implementation behavior: it prefers paid_organic_search_term_view and falls back to paid-only search_term_view when organic fields are unavailable. This adds useful information beyond the name and schema, though it does not describe pagination, output shape, or error 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 a single, information-dense sentence that front-loads the purpose and read-only nature before explaining the fallback behavior. Every clause adds value without 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 an 8-parameter read-only report tool with no output schema and no annotations, the description covers core purpose and fallback behavior but omits return-value expectations and practical usage constraints. The high schema coverage helps, but the lack of output schema means the description could usefully state what fields or rows are returned.

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 88%, so the schema already documents nearly all parameters well. The description adds no parameter-specific semantics, but this is acceptable given the high schema coverage. No credit is needed beyond the baseline.

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

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

The description identifies a specific verb ('get'), resource ('paid/organic search terms report'), and clarifies it is read-only. It reasonably distinguishes itself from a plain search-terms tool by mentioning both paid and organic, though it does not explicitly name the sibling google_ads_get_search_terms.

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

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

The description implies the tool is for retrieving paid/organic search terms and notes the fallback view behavior, which gives some context. However, it does not state when to use this tool versus the sibling google_ads_get_search_terms or any other alternative, leaving the decision primarily to the agent.

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 'Read-only,' which is a meaningful behavioral disclosure since no annotations are provided. It also hints at conditional behavior with 'optional' metrics and 'when available' for top combinations, but it does not explain any practical limitations, such as data availability windows, API cost implications, or what happens when optional metrics are omitted.

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 core purpose and then lists the returned data categories in a scannable way. Every phrase earns its place, with no repetition of the tool name or redundant details.

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

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

For a tool with 8 parameters, no annotations, and no output schema, the description provides a useful but incomplete picture. It names the output categories, which is essential, but it does not clarify how 'optional' metrics are toggled via parameters, what action items and status reasons look like, or what the default behavior is when filters and dates are omitted. The schema fills some gaps, but the overall context is only minimally sufficient.

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

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

Schema description coverage is 75%, so most parameters already carry meaningful descriptions. The tool description itself adds little parameter-specific value, only noting that performance metrics and top combinations are optional, which is already reflected in the schema. Parameters like limit and statusFilter lack descriptions in the schema, and the description does not compensate for those gaps.

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-only Performance Max asset group diagnostics,' which names a specific resource and operation, then enumerates the exact categories of data returned: ad strength, asset coverage action items, primary status reasons, optional performance metrics, and optional top asset combinations. This clearly differentiates the tool from siblings like google_ads_get_pmax_assets, which is about asset inventory rather than diagnostic evaluation.

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

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

The description implies the tool is for PMax asset group diagnostics, and the read-only qualifier suggests it is safe for investigation workflows. However, it gives no explicit guidance on when to choose this over related sibling tools such as google_ads_get_pmax_assets or google_ads_run_gaql, nor does it mention any exclusions or prerequisites.

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 behavioral burden. It adds useful context by naming the source table and mentioning that date-range metrics are optional, but it does not disclose output shape, default date behavior, or whether only certain asset statuses are included. The read-only nature is implied by 'List'.

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

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

One concise front-loaded sentence states the core action and resource first, then adds context and optional metrics. There is no filler or redundant wording; every phrase contributes meaning.

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

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

The description captures the essential resource and optional metrics, but with 8 parameters, no output schema, and no annotations, it leaves the return value shape, metric fields, and differentiation from PMax diagnostic/placement tools underspecified. It is adequate for basic invocation but not fully complete for nuanced agent decision-making.

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 high (75%), so the schema already documents the main parameters including dates, fieldType, customerId, and campaign/asset group IDs. The description reinforces the date-range/performance metric connection but adds no substantial meaning beyond what the schema provides.

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

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

The description uses a specific verb ('List') and clearly scopes the resource to Performance Max asset group assets from asset_group_asset. It is distinguishable from PMax sibling tools like get_pmax_placements or get_pmax_asset_diagnostics, though it does not explicitly name those alternatives.

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

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

The description does not state when to use this tool versus siblings like get_pmax_asset_diagnostics, and provides no explicit exclusions or alternative routing. An agent must infer usage from the tool name and resource phrasing.

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 solid work: it explicitly says 'Read-only', identifies the exact data source, and warns that results are 'impressions only', preventing incorrect assumptions about available metrics. It doesn't disclose pagination or API-limit behavior, but for a read-only diagnostic tool this is meaningful disclosure.

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

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

The description is a single, well-structured sentence that front-loads the most important facts: read-only, Performance Max, and placement diagnostics. Every part contributes value and there is no 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?

Despite having no output schema, the description lists the return fields, making the result shape predictable. The only notable gap is that 'campaign context' is slightly vague and no explicit guidance is given for choosing this over google_ads_run_gaql or other PMAX siblings, but the description is otherwise sufficient for correct invocation.

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

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

Schema description coverage is high at 86%, so the parameters are already well-documented in the schema. The description adds context about the output fields but does not enrich parameter understanding, which is acceptable given the strong schema coverage.

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

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

The description names a specific resource (performance_max_placement_view), states the tool is read-only, and enumerates the exact returned fields: placement type, display name, target URL, campaign context, and impressions only. This clearly distinguishes it from sibling PMAX tools like google_ads_get_pmax_assets or google_ads_get_pmax_asset_diagnostics.

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 'Performance Max placement diagnostics' gives clear context for when to use this tool: when placement-level diagnostics from the performance_max_placement_view are needed. It does not explicitly name alternatives or state when not to use it, so it misses the top score, but the usage 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 exist, so the description carries the behavioral burden. 'List' implies a read-only operation and 'when supported' adds a caveat about impact, which is useful. It does not state pagination/limit semantics or required customer context, though for a list operation these are minor.

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; the key verb/resource and output attributes are packed efficiently, and the 'when supported' caveat is concise.

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

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

For a simple read-only list tool, this is largely complete: schema supplies required customerId, limit bounds, and typeFilter format; description supplies return-field context. Without an output schema or annotations, a little more about response format or pagination would be nice, but the definition is usable.

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 only 50%, and the description does not compensate for the undocumented `limit` and `includeDismissed` parameters. It only describes output fields; it adds no meaning to the input parameters 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 ('List') and a specific resource ('Google Ads recommendations'), then enumerates the returned dimensions (type, resource, links, dismissed state, impact). This clearly distinguishes it from sibling tools because no other sibling targets recommendations.

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 tool name and description imply the use case: any time recommendation data is needed. However, it names no alternatives and gives no exclusions, leaving the agent to infer rather than receive explicit routing guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal the key behavioral trait that the data source switches based on reportType, which is useful. However, it fails to explain how behavior differs between search_term_view and campaign_search_term_insight (e.g., field availability, data retention), and says nothing about return format or that searchTermContains only applies to one mode.

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 a clear verb and no filler; every word carries meaning. It loses one point only because it compresses the reportType distinction into a dependent clause when that distinction arguably merits its own explanatory sentence.

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

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

For a dual-mode tool with 8 parameters, no annotations, and no output schema, this description is incomplete. An agent cannot tell which reportType to use for a given request, how the two views differ in data availability or fields, what the response shape looks like, or how this differs from the paid-organic search-terms sibling. Those gaps make correct invocation a guessing game.

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 75%, so most parameters are already documented in the input schema and the description adds little on top. The mention of reportType merely echoes the enum already present in the schema, and no syntax, formatting, or cross-parameter constraints are added beyond what the schema provides.

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

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

The description uses a specific verb-resource pair ('Fetch search term performance') and names the two report sources it reads from, which gives the agent a concrete sense of scope. It is somewhat distinguishable from the sibling google_ads_get_paid_organic_search_terms by virtue of naming the two reporting views, though it does not explicitly call out that distinction.

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 'depending on reportType' implies a decision point but never explains when to choose one report type over the other, nor when to prefer this tool over the closely related google_ads_get_paid_organic_search_terms or google_ads_get_keyword_performance. No exclusions, prerequisites, or alternative routing are provided, leaving the agent to infer usage entirely.

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 more weight. It does disclose the read-only nature and the report's dimensional structure, which is useful, but it leaves out behavioral details like required date/customer scope, pagination, rate limits, or response shape.

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 efficient sentences with no filler. The key read-only qualifier and differentiating dimensions are front-loaded, and the use case follows in the second sentence.

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

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

Given the absence of an output schema and annotations, the description provides strong domain context and enough directional detail about what the report contains. The schema covers parameter documentation, so the main remaining gap is a more explicit statement of returned metrics, though 'spend/conversions' partially addresses that.

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 91%, so the schema already documents most parameters. The description adds alignment context by naming product dimensions that map to filters such as merchant ID, item ID, brand, and feed label, but it does not meaningfully supplement the limit or date-format 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 clearly identifies a read-only Shopping performance report and specifies the distinguishing key: Merchant Center product dimensions. This separates it from sibling tools like google_ads_get_shopping_products and google_ads_get_keyword_performance.

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

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

It gives a concrete use case: joining spend/conversions to merchant ID, item ID, title, brand, feed label, and custom labels. This helps an agent know when the report is appropriate, though it does not explicitly state when to prefer alternatives or list exclusions.

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

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

With no annotations provided, the description carries the safety-disclosure burden, and it explicitly says 'Read-only,' which is important for an AI agent. It also adds behavioral context by identifying the underlying shopping_product resource and the condition under which performance metrics are available, though it does not discuss pagination or result shape.

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 sentence with no filler, front-loading the read-only nature and the resource being queried. It packs resource type, scopes, and data-availability conditions efficiently.

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 rich schema and 12 parameters, the description does not need to restate parameter mechanics. It provides the key missing context: read-only nature, Merchant Center product catalog/eligibility focus, supported scopes, and the Shopping/PMax condition; no output schema exists, but 'report' plus the schema is reasonably 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?

The input schema already covers 83% of parameters with descriptions, including scope, dates, filters, and IDs. The description adds some meaning by tying scope values to account/campaign/ad_group and linking performance metrics to Shopping/PMax data, but it does not substantially supplement the schema's 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 states a specific verb and resource: 'read-only Merchant Center product catalog/eligibility report via shopping_product.' It also distinguishes this from performance-focused siblings like google_ads_get_shopping_performance by emphasizing catalog and eligibility rather than aggregate performance.

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 relevant by noting account/campaign/ad group scopes and that performance metrics appear only when Shopping/PMax e-commerce data exists. However, it does not explicitly name alternatives or state when to prefer this over sibling tools such as google_ads_get_shopping_performance.

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 behavioral burden. It discloses that the operation is read-only, describes the return content (simulation metadata and projected point lists), and notes a metadata fallback. It stops short of covering pagination or output shape, but the core behavior is 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 two sentences, front-loads the read-only planning/forecast purpose, and includes the fallback behavior without any filler. Every sentence earns its place.

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

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

Although there is no output schema, the description usefully summarizes what is returned and when a fallback occurs. The schema covers most parameters in detail, and the description adds the missing high-level return behavior, making the tool reasonably complete for an agent to invoke 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 90%, so the schema already documents nearly all parameters. The description adds minimal parameter-level meaning beyond naming the resource levels, which map to the 'level' enum. Thus 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 identifies the tool as a read-only planning/forecast query for simulations, and specifies the three supported resource levels: campaign, ad group, and portfolio bidding. This makes it easy to distinguish from sibling tools that handle accounts, keywords, or GAQL 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: use this when you need simulation metadata, forecasts, or projected point lists. It does not explicitly name alternatives or state when not to use it, but the simulation-specific scope is strong enough to guide selection.

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

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

With no annotations provided, the description carries the full burden. It explicitly discloses that the operation is read-only and that secrets are never returned, and it explains what is verified. It stops short of describing output format or potential rate-limit impacts, but the key behavioral traits are 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 sentence of about 20 words, immediately leading with 'Read-only connectivity check.' Every phrase adds information, with no filler or repetition.

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

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

For a parameterless health-check tool with no output schema, the description adequately explains the tool's role and the dimensions it validates. It hints at the output via 'actionable warnings' and explicitly notes that secrets are not included, which is sufficient for safe invocation.

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

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

The tool has zero parameters, and the empty input schema confirms this. A baseline of 4 applies for 0-parameter tools, and the description still provides meaningful context by clarifying the operation is a check that yields warnings rather than a mutation.

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 ('Verifies') and resource ('connectivity') for Google Ads, and enumerates the exact aspects checked: credential presence, API access, login customer visibility, API version, and warnings. This clearly distinguishes it from sibling data-retrieval 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 phrase 'Read-only connectivity check' provides clear context for when to invoke this tool, especially before other Google Ads operations. It does not explicitly name alternatives or exclusions, but the tool's distinct health-check purpose is evident from the 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?

With no annotations provided, the description carries the full disclosure burden. It does contribute real behavioral context: the manager-account traversal is disclosed with the honest qualifier 'attempts', and the credential scope defines the access boundary. However, it does not explicitly confirm read-only safety, pagination, or output limits, leaving some traits to inference from the verb 'List'.

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 filler: the first delivers the core purpose, the second the behavioral nuance. Every clause earns its place, and the 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 zero-parameter listing tool, the description covers purpose, scope, and the only non-obvious behavior — nearly all an agent needs to invoke it correctly. Minor gaps remain: there is no output schema to describe the return shape, and no guidance disambiguates it from google_ads_get_account_hierarchy, but these are minor at this simplicity level.

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

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

The tool has zero parameters, so the input schema is trivially complete and there is nothing for the description to clarify about arguments. The 0-parameter baseline of 4 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?

States a clear verb-resource pair — 'List Google Ads customer accounts' — scoped to 'accessible with the current credentials'. The second sentence adds a behavioral nuance (including enabled child accounts from customer_client) that helps separate it from siblings like google_ads_get_account_details. The purpose is unmistakable.

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 usage context — enumerating the accounts reachable with the current credentials — but never states when not to use it or names a preferable alternative. An overlapping sibling, google_ads_get_account_hierarchy, exists in the sibling list and is not contrasted, so the agent must infer the boundary itself.

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 must carry the full behavioral burden. It reveals that the tool executes a raw query and gives a SELECT example, but it does not disclose whether only read-only queries are allowed, how results are returned, what happens on invalid queries, or any rate limits or pagination behavior. These are significant unknowns for a raw-execution 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?

The description is concise and front-loaded: the first sentence states the purpose, and the second provides an illustrative example. Every sentence earns its place, and the example is compact enough to be immediately useful without bloating the description.

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

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

This is a high-flexibility raw query tool with no output schema and no annotations, yet the description omits key contextual details: return format, whether the tool is read-only, how to handle errors, and any pagination or duration limits. The example hints at capabilities but does not fully equip an agent to safely and effectively invoke the tool for arbitrary GAQL queries.

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% for both parameters, and the schema descriptions already convey basic semantics and the customer ID format. The description adds value beyond the schema by providing a realistic GAQL example with SELECT ... FROM ... WHERE ... DURING ... ORDER BY ... LIMIT, which clarifies the expected query structure and demonstrates the granularity of fields available.

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 raw GAQL query and offers 'full flexibility for any reporting need,' which specifies a distinct resource (GAQL). It does not explicitly differentiate itself from closely related siblings like google_ads_run_readonly_rpc or google_ads_validate_query, so it misses the top score.

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

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

The description provides no explicit when-to-use guidance, no exclusions, and no mention of alternative tools. While 'Full flexibility for any reporting need' implies broad use, it does not tell an agent when to prefer this over the many sibling reporting tools or when to avoid it, leaving selection 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?

With no annotations provided, the description carries the behavioral disclosure burden. It clearly states that the operation is an enum, that arbitrary paths are impossible, and that all mutations/uploads are impossible. This meaningfully informs the agent about safety and flexibility boundaries, though it does not cover rate limits, auth requirements, or response 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 and front-loaded with the most important scoping statement ('read-only escape hatch... outside GAQL'). The long list of services and the explicit safety constraint are useful, though 'Advanced' adds little and the sentence is dense.

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 RPC-based tool with no output schema and no annotations, the description provides a good high-level map of what it can access and constrains it to safe read-only operations. However, it lacks guidance on how to choose among the 29 operations, what request fields each operation expects, or what the response structure looks like, leaving the agent to rely heavily on the operation names and external API 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?

Schema coverage is 67%, with request and customerId already described in the schema. The description adds service-area context that helps interpret the enum operations (e.g., Audience Insights vs. invoices), but it does not map specific operations to specific request shapes or explain how to construct the request object for the listed RPCs.

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 a read-only RPC escape hatch for Google Ads services outside GAQL and enumerates the specific service areas it covers (Audience Insights, Reach Planner, benchmarks, etc.). It distinguishes itself from the GAQL-based sibling tools by explicitly marking itself as outside GAQL and non-mutating.

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

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

The description states this is for 'allowlisted Google Ads services outside GAQL,' which gives clear context for when to use it versus GAQL querying tools. It also explicitly excludes mutations and uploads, so an agent knows not to reach for it for write operations. However, it does not name a specific sibling alternative or give a more detailed decision rule for choosing among the many similar getter tools.

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

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

With no annotations, the description carries the transparency burden and does disclose that the tool is 'Read-only.' It also describes the live nature of the catalog and its role before raw GAQL queries. However, it does not mention behavior such as pagination, how results are returned, or interaction between the raw query parameter and structured filters, despite the presence of pageToken, pageSize, and query 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 filler: a front-loaded action sentence followed by one clarifying scope sentence. Every phrase adds information about what the catalog contains and when to use the tool.

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

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

For a tool with 8 parameters, no annotations, and no output schema, the description provides useful high-level context and a clear workflow placement. However, it does not describe the return value shape, pagination behavior, or the relationship between the query parameter and the structural filters, leaving meaningful gaps an agent would need to infer from the schema alone.

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 only 25% across 8 parameters, so the description needed to compensate, but it does not explain most parameters. It mentions categories like 'resource, attribute, segment, metric' and 'selectable-with compatibility,' which hint at category and selectable, but sortable, filterable, pageToken, and the interaction between query and structured filters remain unexplained in the description.

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: 'Search Google's live GoogleAdsField catalog.' It further enumerates the exact kinds of entities discovered (resource, attribute, segment, metric, enum value, selectable-with compatibility) and explicitly ties it to use before a raw GAQL query. This clearly distinguishes it from siblings like google_ads_run_gaql.

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?

'Read-only and useful before a raw GAQL query' gives a clear usage context and signals that this is a discovery step rather than a query execution tool. It does not explicitly name alternatives or exclusions, but the contrast with raw GAQL query execution is clear from the sibling set and the wording.

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 behavioral disclosure burden. It explicitly states 'Read-only,' which is a key safety behavior, and details what the operation returns: criterion IDs, canonical names, target types, status, parents, locale, and approximate reach. It does not cover failure or partial-resolution behavior, but the core behavioral profile is clearly 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?

The description is three short sentences, with the primary purpose front-loaded before the return details. Every clause adds useful information, and there is no redundant or filler text. It is concise while still conveying both purpose and output expectations.

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 has 4 parameters, no annotations, and no output schema, the description is moderately complete: it states the operation, the read-only nature, and the return fields. However, it leaves countryCode unexplained, does not clarify the exact return structure, and says nothing about failure behavior or how the two input arrays interact. An agent could call it correctly but would lack full context for all inputs.

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 0%, so the description must explain the parameters. It covers geoTargetIds and locationNames by describing them as 'location names or geo target IDs' and notes the 25-item limit, but it does not explain countryCode at all. Locale is mentioned only as a returned field, not as an input parameter controlling language, which could mislead an agent. Parameter semantics are only partially compensated.

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

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

The description states a specific action, 'Resolve', and a specific resource, 'location names or geo target IDs to Google Ads geoTargetConstants', making the tool's job unmistakable. It also lists concrete return fields, which distinguishes it from the many read-only reporting siblings. No ambiguity about what this tool does.

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

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

The description implies usage context: when an agent needs to translate location names or geo target IDs into Google Ads geo target constants. However, it does not explicitly state when to use this tool versus alternatives or when not to use it, and no sibling alternative is named. The uniqueness among siblings makes this a mild gap rather than a serious one.

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

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

No annotations are provided, so the description carries the full burden of disclosure. It usefully reveals that the tool checks segment restrictions and resource availability and implies it does not execute the query itself. However, it does not describe the return format, failure behavior, or whether it performs any I/O, which leaves important behavioral gaps.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase contributes meaning: what it validates, the timing, and the specific checks performed.

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 only three parameters and no nested objects, so the description is largely adequate for calling it. However, there is no output schema and the description does not state what the tool returns (e.g., boolean, list of errors, or throwing an exception), leaving an important gap for the agent.

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

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

The schema describes metrics and dimensions, but resource only has a default value. The description adds relational meaning by tying metrics, dimensions, and resource together into a compatibility check, which is not obvious from the schema alone. It does not enumerate valid keys or segment restriction details, but it compensates for the moderate schema coverage.

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

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

The description uses a specific verb ('Validate') and a clear object ('metric/dimension/resource compatibility'), and the qualifier 'BEFORE executing a query' distinguishes this from execution-oriented siblings like google_ads_run_gaql. An agent can immediately tell this is a pre-flight validation tool rather than a query runner.

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 frames when to use the tool: before executing a query. It also specifies what it checks (segment restrictions, resource availability), giving the agent actionable context. However, it does not explicitly name alternatives or state when NOT to use it, such as when the user actually wants to run the query.

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