Google Ads

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

Annotations indicate idempotentHint=true but no destructive behavior. The description adds context about browser login, token copying, and the distinction between permanent and session-based auth. It doesn't contradict annotations and adds useful behavioral detail about the authentication flow, though it could mention what happens on successful/failed auth.

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 paragraph but logically organized: first the purpose, then the recommended permanent method, then the session alternative. It's slightly verbose with the phrase 'MCP.AI for IDE agents' which is context, but not wasted. Could be tightened slightly but remains clear.

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

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

Given the tool's simplicity (1 optional param, no output schema), the description fully covers the authentication flow, including the two usage modes and the role of the token. It also implicitly explains why an agent would call this tool (to get a link or send a token). No gaps remain.

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 has one param 'token' with no description (coverage 0%). The description fully explains the parameter: it's a JWT that can be passed for session login, and that calling with no args returns a link. This provides complete semantics beyond the schema.

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

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

The description clearly states the purpose: authentication for MCP.AI IDE agents, with specific instructions for obtaining an access token. It distinguishes between permanent (config header) and session-only (token argument) modes, making it distinct from the sibling tools which are all Google Ads operations.

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?

Explicitly explains two workflows: adding a header for permanent connection vs. pasting a token for session-only. It also specifies exactly what to call with arguments (`{ token: ... }`) and without args (get link), leaving no ambiguity on when and how to use the tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. The description adds context about response structure (authenticated flag, pending[], connect_url), which is valuable beyond annotations. It doesn't contradict annotations.

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

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

Two sentences, front-loaded with purpose, then adds conditional detail. No wasted words. Slightly longer than necessary but each clause adds value.

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

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

For a simple status tool with 0 params and no output schema, the description covers key return conditions (connected vs missing credentials) and what URLs appear. No mention of rate limits or detailed error cases, but for this simplicity it's adequate.

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 0 parameters, so there's nothing to add beyond schema. However, since no parameters exist, the description effectively explains the tool's behavior fully without needing param docs. Baseline for 0 params is 4, and the description does a good job explaining output conditions.

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 returns connection status and URLs, and distinguishes between connected vs missing credentials scenarios. It is specific (verb: returns, resource: connection status) but doesn't explicitly differentiate from siblings like 'authenticate' or 'google_ads_status', though the target is clear.

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

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

The description implies when to use it (to check connection status) but doesn't explicitly state when not to use it or mention alternatives. The sibling 'authenticate' likely handles the actual authentication flow, and this tool is for checking status, but that contrast isn't stated.

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

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

Annotations already establish that this is a safe, read-only, idempotent operation. The description adds meaningful extra behavior by disclosing bulk execution support and how scope is resolved using account and customer_id. It does not contradict annotations and provides useful operational context beyond the safety hints.

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: the first sentence states the core purpose and outputs, and the second sentence adds the bulk behavior cleanly. No filler words or unnecessary repetition of schema properties.

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

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

Given no output schema, the description tells the agent what fields will be returned and how scope is resolved. It could be more detailed about required parameter combinations and bulk execution semantics, but for a simple lookup tool the description is largely sufficient.

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

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

Schema description coverage is 0%, so the description carries the burden for explaining the parameters. It does explain that account and customer_id resolve scope and that customer_ids enables batched execution, but it leaves ambiguity around whether one is sufficient, whether both are required, and what exactly account represents in relation to customer_id.

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

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

The description clearly identifies the tool's action ('Get Google Ads account info') and specifies the returned fields (name, currency, timezone), making its purpose concrete. It also distinguishes itself from sibling tools by focusing on a single customer's account info rather than listing accounts or managing campaigns.

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

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

The description provides useful context: the tool targets a specific customer and uses account + customer_id to resolve scope. It also notes bulk support via customer_ids, but it does not explicitly state when to prefer this over alternatives like google_ads_list_accounts, so it lacks explicit exclusion guidance.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, so the description is not contradicting them. The description adds useful behavior info: default status ENABLED, default type SEARCH_STANDARD, optional cpc_bid meaning, and bulk input support. However, it does not disclose side effects like what happens if campaign_id is invalid, whether creating an ad group changes campaign status, or whether bulk execution is atomic.

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 short and front-loaded with the core purpose, followed by defaults and optional behaviors. It uses three compact sentences and avoids verbosity. However, given the 9-parameter schema, it could have added a bit more structure (e.g., a short parameter list) without becoming bloated.

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 tool has 9 parameters, no output schema, minimal annotations, and zero schema coverage. The description is not complete enough: it fails to explain required parameters (campaign_id, name), enum parameter meanings (type, status), the account/customer_id distinction, and expected return value. The bulk support note is useful but does not cover the broader operational context needed for a creation 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?

Schema coverage is 0%, so the description must compensate, but it only explains cpc_bid and mentions bulk campaign_ids/customer_ids. It does not explain the meaning or usage of campaign_id, name, type, status, account, customer_id, or how the singular and plural forms relate. The description adds some value (cpc_bid semantics and bulk fields) but leaves most parameters unexplained.

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 says 'Create an ad group inside a campaign' with a specific verb, resource, and location, and it lists defaults (ENABLED, SEARCH_STANDARD) and key options (cpc_bid). It clearly identifies the operation but does not explicitly distinguish it from sibling tools like google_ads_ad_group_update_status, which is a different operation but the name and description make the distinction fairly obvious.

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

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

The description provides clear context that this is for creating ad groups and mentions the default type/status, so an agent knows when to use it (when creating an ad group). However, it gives no explicit guidance on when not to use it or alternatives (e.g., when to use google_ads_keyword_add or google_ads_ad_group_update_status instead).

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, which indicate a mutating operation. The description adds important information that REMOVED is irreversible, which is a critical behavioral trait not fully captured by the annotations. However, it does not mention other behaviors like whether the operation is idempotent or what happens on partial failure, though the partial_failure parameter exists. Overall, it adds some value beyond the annotations but not extensive 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 description is very concise: 'Pause, enable or remove ad groups. REMOVED is irreversible.' Two short sentences with no redundancy. It is front-loaded with the action and adds the critical warning. Excellent for a tool with as few parameters as this.

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 a mutating operation with 5 parameters and no output schema. The description covers the core action and the irreversible nature of REMOVED, but it lacks details on parameters like partial_failure, which could be important for agents handling errors. Given that it is a straightforward mutation with clear enum values and standard param names, the description is adequate but not exhaustive. Some guidance on the effect of partial_failure would have made it more complete.

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

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

The input schema has 5 parameters with 0% coverage in the description. The description only explains the status parameter through the enum values (ENABLED, PAUSED, REMOVED) and the warning about REMOVED. It does not explain ad_group_ids, account, customer_id, or partial_failure. Since these are largely self-explanatory (e.g., customer_id, account) and the schema has enums for status, the description adds some meaning but does not fully compensate for the lack of param details. Baseline is 3 given high schema clarity on status and typical parameter names.

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

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

The description clearly states the tool's function: 'Pause, enable or remove ad groups.' It uses a specific verb and resource, and the context distinguishes it from sibling tools like google_ads_ad_group_create (create). However, it could more explicitly differentiate from the similar google_ads_ad_update_status for ads, but the resource is clearly named.

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

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

The description mentions the three possible statuses and warns that REMOVED is irreversible, which gives some context for when to use it. However, it does not provide explicit guidance on when to use this tool versus alternatives (e.g., for creating or updating other attributes). The context implies you would use this for status changes, but no alternatives are named.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond those hints, including the specific policy_summary fields returned and the ability to execute against multiple customer_ids in bulk. No contradictions with annotations.

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

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

The description is compact and front-loaded, with the first sentence stating what the tool does and what it returns. The second sentence adds a distinct bulk-execution capability. Every sentence adds value with 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?

For a simple read-only listing tool with no output schema, the description covers the tool's purpose, returned fields, a motivating use case, and bulk behavior. The main gap is the unresolved semantics of account and customer_id, but overall the description is sufficiently complete for most selection and invocation scenarios.

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 compensate for parameter meaning. It only explains customer_ids as providing bulk execution; the purpose and relationship of 'account' and 'customer_id' are left unspecified. This is insufficient for fully guiding an agent on how to supply 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 uses a specific verb and resource: 'List enabled ads' followed by the exact fields returned (type, status, campaign name, policy_summary details). It clearly distinguishes this from sibling tools like google_ads_campaigns or google_ads_keywords by focusing on ads and their policy approval/review status.

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 a concrete use case: answering 'why is my ad not serving?' without opening the Google Ads UI. It also notes bulk support via customer_ids. It does not explicitly mention when not to use the tool or name alternatives, but the context is clear enough for an agent to select it over related read/write ad tools.

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

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

Annotations are minimal (all false), so the description carries some burden. It states the actions (pause, enable, remove) but does not disclose side effects (e.g., removal being permanent) or error handling. It adds the keying detail, which is useful, but could be more explicit about the consequences of 'REMOVED'.

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 fluff, front-loading the core action and then adding essential usage details. 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 mutation tool with no output schema and minimal annotations, the description covers the essential usage: what it does, the keying requirement, and bulk execution. It omits details about return values, partial failures, and account targeting options, but the description is sufficient for an experienced agent to use it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It clarifies the structure of 'ads' (each needs ad_group_id and ad_id) and the bulk capability via customer_ids. However, it does not explain the difference between account, customer_id, and customer_ids, nor the purpose of partial_failure, leaving those parameters underspecified.

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

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

The description clearly states the action ('Pause, enable or remove ads') and the resource ('ads'), which is distinct from sibling tools like google_ads_ad_group_update_status (which targets ad groups) and google_ads_campaign_update_status. It also specifies the required keying (ad_group_id + ad_id), adding precision.

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

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

The description provides usage context by explaining that each entry needs both ad_group_id and ad_id and mentions bulk support via customer_ids. It does not explicitly compare with alternatives, but the resource-specific wording effectively differentiates it from 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?

The description adds meaningful operational detail beyond the annotations: the amount is daily and denominated in the account currency, with a concrete example (50 = R$50/day). It also discloses bulk support through customer_ids. These details help the agent anticipate behavior and multiple-account workflows.

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 short but information-dense. It front-loads the core purpose, then adds essential constraints and bulk support in a compact format. Both sentences contribute meaningful information without redundancy.

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

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

Given no output schema and minimal annotations, the description still provides key contextual points: creation purpose, required-before-campaign relationship, amount interpretation, and bulk execution. It does not explain all parameters or cover return behavior, but the main agent guidance is sufficient for a straightforward create 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?

Schema description coverage is 0%, so the description must compensate. It does clarify amount semantics (daily, account currency) and mentions customer_ids for batched execution, but several parameters—name, account, customer_id, delivery_method—receive no additional meaning. The schema's names provide some hint, but not full compensation for the lack of descriptions.

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

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

The description starts with 'Create a campaign_budget', using a specific verb plus resource. It also places the tool in context by noting it is required to create a campaign, which distinguishes it from sibling update/list tools like google_ads_campaign_update_status and google_ads_campaign_update_budget.

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

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

The description explicitly notes this tool is required before creating a campaign, giving clear timing context for when it should be used. It does not explicitly contrast with alternatives, but the sibling set makes the role of this creation tool reasonably evident.

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

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

The description exceeds the sparse annotations by disclosing default values and their safety intent ('status=PAUSED (safe)'), the prerequisite budget relationship, the EU political advertising default, and bulk execution capabilities. These are important behavioral traits not otherwise available from the annotations or 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 brief yet information-dense. Each sentence adds value: purpose, defaults, prerequisite, compliance note, and bulk support. It is front-loaded with the main action and avoids filler.

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

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

For a tool with 10 parameters and no output schema, the description covers key aspects: defaults, prerequisites, bulk support, and legal compliance. However, it omits the return value/response behavior and leaves some parameters (e.g., 'account') under-specified, which slightly reduces completeness.

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?

With 0% schema description coverage, the description compensates by adding defaults for channel_type, status, and bidding_strategy; explaining budget_id as a prerequisite; and clarifying bulk usage of budget_ids/customer_ids. However, it leaves 'account', 'customer_id' (singular), and 'name' without additional explanation, so it is not fully comprehensive.

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 'Create a Google Ads campaign,' which is a specific verb + resource. It clearly distinguishes itself from sibling tools like google_ads_ad_group_create and google_ads_campaign_budget_create by focusing on the campaign entity and providing default settings (channel_type=SEARCH, status=PAUSED, bidding_strategy=MANUAL_CPC).

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 a clear prerequisite ('Provide budget_id from google_ads_campaign_budget_create') and mentions bulk support, which guides when to use it. However, it does not explicitly state when not to use this tool or name alternative tools for campaign updates, so it lacks exclusions.

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

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

The annotations already mark this as readOnly, idempotent, and non-destructive. The description adds meaningful behavior beyond annotations: the default ALL behavior, explicit exclusion of REMOVED campaigns, and bulk execution support via customer_ids. There is no annotation contradiction.

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

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

The description is concise and efficiently structured in two sentences. It leads with the core purpose, then explains status behavior and bulk support without unnecessary filler or repetition of schema details.

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

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

The tool is a simple listing tool with annotations already covering safety and idempotency. The description covers purpose, statuses, REMOVED exclusion, and bulk support. Minor gaps remain on the account/customer_id meaning and result shape, but the core context 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?

With 0% schema description coverage, the description must compensate. It does clarify the status parameter and defaults, and explains that customer_ids enables bulk execution. However, it leaves account and customer_id ambiguous, and the schema itself provides no descriptions.

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

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

The description clearly states the tool lists Google Ads campaigns with status and budgets. It distinguishes this read-only listing from sibling create/update tools and specifies the different status filtering 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?

Usage guidance is direct: the default ALL behavior is explained, filtering by ENABLED/PAUSED is shown, and REMOVED campaigns are explicitly excluded. It does not mention when to use alternative tools like google_ads_campaign_create or google_ads_campaign_update_status, so it stops short of full when-not guidance.

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

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

Annotations already indicate this is a mutating operation (readOnlyHint=false), and the description adds meaningful behavior beyond that: amounts are provided in account currency and internally converted to micros, and bulk execution is supported. It does not mention idempotency or exact effects, but it offers useful operation semantics not present in the structured fields.

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

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

The description is concise, front-loaded, and every sentence adds value: the first states the core operation and amount format; the second covers bulk support. No filler or redundancy remains.

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 mutation tool with no output schema and rather sparse annotations, the description covers the main required inputs and the currency conversion behavior. It still leaves ambiguity around optional parameters (account, customer_id) and does not clarify how singular and plural forms interact in batch use.

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

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

With 0% schema description coverage, the description must compensate for parameter meaning. It explains amount formatting and the use of campaign_ids/customer_ids for bulk, but it leaves account, customer_id, and the relationship between singular and plural parameters under-specified.

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 action, 'Update the daily budget of a campaign,' and clearly identifies the inputs (campaign id and new amount). It distinguishes itself from sibling tools like google_ads_campaign_budget_create and google_ads_campaign_update_status by focusing on daily budget modification.

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 conveys when to use the tool (for updating a campaign's daily budget) and even notes bulk execution via campaign_ids and customer_ids. However, it does not explicitly state when not to use it or name alternative tools for other budget/status operations.

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

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

Annotations indicate a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds key behavioral details: REMOVED is irreversible and Google rejects changes on trial campaigns. This goes beyond the annotations and helps the agent understand risks and limitations. No contradiction detected.

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

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

The description is three concise sentences: the first states the purpose, the second warns about irreversibility, and the third gives a limitation. Every sentence earns its place with no redundancy or fluff.

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 status-update tool with 5 parameters and no output schema, the description covers the core action, source of IDs, and an important limitation. It could mention partial_failure behavior or batch limits, but the essential context is present. It is adequately complete for this tool's complexity.

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

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

With 0% schema description coverage, the description must compensate for unexplained parameters. It provides context for campaign_ids ('Pass campaign ids from google_ads_campaigns') and status is self-evident from the enum. However, account, customer_id, and partial_failure are not explained, leaving some parameters ambiguous. The description partially covers the gap but not fully.

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

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

The description clearly states the action (pause, enable, or remove) on a specific resource (Google Ads campaigns), distinguishing it from sibling tools like create or budget updates. It is specific and actionable.

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 context by instructing to pass campaign ids from google_ads_campaigns and notes a constraint (trial campaigns cannot be changed via API). It does not explicitly list exclusions but implies the appropriate use case for status changes. Sibling tool names make differentiation 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?

Annotations already declare the tool read-only and idempotent, but the description adds additional behavioral context: data comes from the last-30-day change_event, per-customer scope, includes user_email/client/operation/field-mask/resource, and supports bulk execution via customer_ids. It also states exactly which entity types are covered, which is non-obvious without the description.

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

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

The description is compact and efficient: a clear summary sentence, a rich specification of coverage, then a quick usage/format line for date filtering, one line on polling, and one line on bulk support. Every sentence earns its place; there is no verbose fluff or repetition.

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

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

Without an output schema, the description delivers substantial context about return values (user_email, client, operation, field mask, old/new resource) and behavior (30-day window, per-customer, bulk). It only misses details about 'limit' behavior, default page size, and the precise semantic of 'account' meaning, so it is complete but not exhaustive.

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?

With zero schema description coverage, the description carries the burden of explaining parameters. It successfully explains 'since', 'until', 'days', 'customer_ids', and the incremental pattern. It leaves 'limit' and 'account' vs 'customer_id' under-explained, but the most critical filtering semantics are well documented.

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 'Change history / audit log' and immediately states the resource: 'who changed what in the account and when.' It differentiates itself from sibling tools like google_ads_campaigns or google_ads_ads, which return current entity states, by explicitly listing covered entities (campaigns, ad groups, ads, keywords, budgets, bids) and event metadata (operation, field mask, old→new resource).

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

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

The description gives clear usage context: use this tool to inspect audit history, with specific filter options ('since'/'until'/'days') and an explicit incremental-polling pattern. It does not name alternate tools to use instead, make it clear when not to use this tool. The guidance is strong but lacks explicit exclusions.

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

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

Annotations only provide generic false hints, and the description adds some context: bulk support and keyword field structure. It does not disclose partial_failure behavior, status defaults, or response/error semantics, leaving limited behavioral transparency.

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

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

Three concise sentences front-load the core purpose, then present the keyword format, then mention bulk capability. No filler or redundant restatement.

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 mutating tool with 8 parameters and no output schema, this is incomplete: no return value, no explanation of partial_failure, and the bulk mention creates ambiguity about whether ad_group_id is still required when ad_group_ids is used.

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?

With 0% schema description coverage, the description must compensate, but it only documents keyword text/match_type/cpc_bid and names ad_group_ids/customer_ids. It leaves ad_group_id, customer_id, status, account, and partial_failure unexplained, so parameter coverage is insufficient.

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 clearly states 'Add positive keywords to an ad group' with a specific verb, resource type, and target. It naturally distinguishes from siblings like google_ads_negative_keyword_add and keyword update tools.

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

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

The description implies use for adding positive keywords and notes bulk execution via ad_group_ids and customer_ids. However, it never explicitly contrasts with the negative keyword tool or explains when to use single vs. bulk fields.

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

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

Annotations already provide readOnlyHint:true, idempotentHint:true, destructiveHint:false, so the safe read-only nature is covered. The description adds behavioral context beyond annotations: it mentions the `diagnostics` action bundles budget-loss as _campaign_budget_loss, explains why (budget is campaign-level), and specifies default data windows (last 7 days, top 50). This is additional transparency about data scope and bundling behavior, which is not in annotations.

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

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

The description is dense and information-rich, but it is a single long paragraph with many nested parentheses and clauses, making it somewhat hard to parse. It front-loads the main purpose but becomes list-like in the middle. Although it's concise in word count relative to the scope, it could be better structured with bullet points or clearer separation of actions. Still, 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?

Given the high complexity (9 parameters, 5 distinct actions, bulk support, no output schema), the description is remarkably complete. It covers scope (account + customer_id), time frames, filters, default limits, and answers common questions. It even explains the rationale for bundling budget loss. The lack of output schema is mitigated by detailed descriptions of what each action returns (e.g., approval_status, system_serving_status, Quality Score). Context is fully addressed.

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 compensate for 9 parameters. It does by explaining that 'diagnostics' supports campaign_id/ad_group_id filters and days=7|14|30, and mentions bulk support for campaign_ids, ad_group_ids, customer_ids. However, it does not detail the exact meaning of 'account' vs 'customer_id' or 'query' (though query is for raw). Despite some gaps, it adds significant semantic value beyond the schema, which has no descriptions at all.

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 combined diagnostics tool for Google Ads keywords, with a specific verb 'analytics' and distinct action modes (keywords, search_terms, status, diagnostics, raw). It explicitly names sibling tools (google_ads_keywords_keywords, google_ads_keywords_status, etc.) and differentiates by providing a unified interface, thus distinguishing from 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 explicitly outlines when to use each action (e.g., 'status' answers 'why is my keyword not serving?', 'diagnostics' answers 'is it bid or Quality Score?') and mentions bulk support. It also indicates the `raw` action for any GAQL SELECT, and provides filters like days=7|14|30, which are clear usage guidelines. While it doesn't explicitly say 'when not to use', the action-specific guidance is strong 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral context: it specifies time windows (last 7 days, days=7|14|30), result limits (top 50), and the bundling of campaign budget loss into a synthetic field. It also explains the 'raw' action for custom GAQL SELECT. However, it doesn't disclose potential rate limits, pagination behavior, or what happens when no data is available, but given the annotations cover the core safety aspects, this is a strong score.

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

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

The description is dense but well-structured: it starts with a high-level summary, then lists actions with examples, and ends with bulk support. It's front-loaded with the most important info (purpose and actions). However, it's somewhat long and could be trimmed without losing value (e.g., the parenthetical examples are helpful but could be shortened). The use of backticks and clear action names aids readability. Overall, it's efficient but not perfectly 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?

Given the tool's complexity (9 parameters, multiple actions, no output schema), the description is quite complete. It covers the main actions, their outputs (e.g., 'approval_status, system_serving_status'), and the reasoning behind the design (budget as campaign property). It also mentions bulk support and time windows. However, it doesn't describe the return format or how to interpret the 'raw' output, and it doesn't explicitly state that the tool is read-only (though annotations cover that). For a tool with no output schema, this is a strong description, but a perfect score would require more detail on output structure and edge cases.

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 compensate. It does: it explains that 'account' and 'customer_id' are used for scope, and that 'days' accepts 7|14|30 for diagnostics. It also mentions bulk parameters (campaign_ids, ad_group_ids, customer_ids) and the 'query' parameter for raw GAQL SELECT. However, it doesn't explicitly map each parameter to its purpose (e.g., what 'ad_group_id' vs 'ad_group_ids' do differently), and the 'query' parameter is only implied via 'custom GAQL SELECT'. Still, the description provides enough context for an agent to infer parameter usage, so a 4 is appropriate.

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

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

The description clearly states the tool's purpose: 'Keyword analytics, search terms, status/policy diagnostics, auction diagnostics, or custom GAQL SELECT.' It enumerates specific actions (keywords, search_terms, status, diagnostics, raw) with concrete examples (e.g., 'RARELY_SERVED for Low search volume'), distinguishing it from sibling tools like google_ads_keywords_diagnostics and google_ads_keywords_raw by noting that this tool bundles those actions under one interface. The verb 'analytics' and resource 'keywords' are specific, and the scope ('Uses account + customer_id') is explicit.

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 explicit when-to-use guidance: it answers questions like 'why is my keyword not serving?' for status, and 'is it bid or Quality Score?' for diagnostics. It also explains the difference between actions (e.g., 'bundles per-campaign budget-loss as _campaign_budget_loss since budget is a campaign property, not keyword') and notes bulk support for campaign_ids, ad_group_ids, customer_ids. While it doesn't explicitly say 'use this instead of X', the action list and examples make it clear when to use this tool versus the specialized siblings (e.g., google_ads_keywords_diagnostics, google_ads_keywords_raw).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that it uses account+customer_id for scope, supports bulk execution, and for diagnostics includes day range and campaign budget loss. However, it does not disclose the output format or any additional behavioral traits for the raw action beyond saying it accepts any GAQL SELECT. Since annotations cover the safety profile, the description adds some 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?

The description is long and covers multiple actions, which is unnecessary for a tool named 'raw'. It front-loads a laundry list of actions, then provides detailed explanations for each, including examples. This is over-specified and dilutes the focus. A concise description for the raw action (custom GAQL) would suffice, with a note that other actions are available in sibling tools.

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

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

Given the tool's complexity (9 params, no output schema, no parameter descriptions), the description is incomplete. It does not explain what raw GAQL SELECT returns, how to construct a valid query, or provide examples. It also doesn't cover all parameters or indicate which are required for different actions. The description is not enough for an agent to correctly invoke the tool, especially for the raw action.

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?

With schema description coverage at 0%, the description must explain all 9 parameters, but it only partially does. It mentions account and customer_id for scope, campaign_id/ad_group_id filters for diagnostics, and days=7|14|30 in diagnostics. However, it does not clarify the 'query' parameter (beyond saying raw accepts any GAQL SELECT), nor the plural IDs (campaign_ids etc.) beyond bulk support. The description is not sufficient to understand how to use all parameters effectively.

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 lists many actions (keywords, search_terms, status, diagnostics, raw) but the tool name and '[Flattened action: raw]' indicate its primary purpose is custom GAQL SELECT. It does state 'custom GAQL SELECT' as one of the actions, but the rest of the description confuses the scope by detailing all actions. It is not a tautology but lacks focus on the raw action specifically.

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

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

No explicit guidance on when to use this tool versus the sibling tools (e.g., google_ads_keywords_diagnostics, google_ads_keywords_keywords). The description mentions actions but does not say 'use this for raw queries only' or 'for other actions use the dedicated tools'. The bulk support is mentioned but not tied to a specific use case. This leaves the agent without clear decision guidance.

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

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

The description discloses a lot of behavioral detail beyond the read-only/idempotent annotations: 7-day default, top-50 limit, approval_status/system_serving_status/disapproval_reasons, bundled `_campaign_budget_loss`, supported filters, and days values. The main transparency gap is the cryptic flattened-action note and the lack of an action-selection mechanism, but nothing contradicts the annotations.

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

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

The description is dense but front-loaded with an overall summary, followed by labeled actions and bulk support; nearly every sentence adds useful information. The '[Flattened action: search_terms]' line is confusing and unintegrated, which slightly harms structure, but overall it is compact for the amount of detail provided.

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 gives strong return expectations for each action—metrics, statuses, diagnostics fields, and the custom `_campaign_budget_loss`—and lists filters and day ranges. However, there is no output schema, and the missing action-selection mechanism means the description does not fully equip an agent to invoke the tool correctly, especially if the tool is actually only the search_terms action.

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?

With 0% schema description coverage, the description compensates partly by explaining account/customer_id scope, campaign/ad_group filters, days options, and bulk IDs (campaign_ids, ad_group_ids, customer_ids). However, it does not clearly explain the `query` parameter for raw GAQL SELECT, and it never maps the listed actions to a parameter that selects them, which is a significant invocation gap.

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 explicitly lists multiple actions—keywords, search_terms, status, diagnostics, raw—and gives specific verbs and resources, so it is not vague. However, the tool name and the '[Flattened action: search_terms]' note suggest the actual tool is only the search_terms action, and the description heavily overlaps with sibling tools like google_ads_keywords_status and google_ads_keywords_diagnostics without clarifying the 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?

It provides useful intent guidance for sub-actions, e.g., status answers 'why is my keyword not serving?' and diagnostics answers 'is it bid or Quality Score?'. However, it never states when to use this combined tool versus the dedicated sibling tools, and it does not explain how to switch between the documented actions, leaving usage ambiguous.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so safety is known. The description adds behavioral detail: it returns all enabled keywords with approval_status, system_serving_status, disapproval_reasons, and bundles campaign budget loss as `_campaign_budget_loss`. It does not describe pagination or rate limits, but it covers the key output semantics beyond the annotations.

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

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

The description is long and includes a list of actions (keywords, search_terms, diagnostics, raw) that are not relevant to the tool since it's flattened to status. This extraneous content adds verbosity and could confuse an agent. The structure is organized with a summary, actions list, and bulk support note, but the irrelevant parts could be trimmed for conciseness.

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

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

Given no output schema, the description must explain return structure well. It does mention key fields (approval_status, system_serving_status, disapproval_reasons) and the `_campaign_budget_loss` field. However, it lacks clarity on pagination, result size limits (for status it says ALL enabled keywords, but no mention of max results or batch handling), and how parameters like query play in. It covers essentials but not fully, making it adequate yet incomplete.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does clarify that account + customer_id set scope, supports campaign_id/ad_group_id filters, and mentions days=7|14|30 for diagnostics. However, it does not explain `query` (likely for raw action, but flattened to status? ambiguous), nor the exact meaning of `account` vs `customer_id`. Bulk ids are mentioned generically. Partial compensation but lacks completeness.

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

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

The description clearly state it provides keyword status/policy diagnostics (approval_status, system_serving_status, disapproval_reasons) and answers 'why is my keyword not serving?', distinguishing it from sibling like diagnostics and keywords. However, it lists multiple other actions (keywords, search_terms, raw) that are not the tool's actual scope after flattening to status, introducing some ambiguity about the core purpose.

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

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

It explicitly contrasts status ('why is my keyword not serving?') with diagnostics ('is it bid or Quality Score?'), guiding when to use this tool versus alternatives. It also mentions bulk support and supported filters (campaign_id, ad_group_id, days=7|14|30), giving clear context for invocation. No explicit when-not-to-use statements, but the action differentiation provides strong guidance.

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

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

Annotations indicate readOnlyHint=false, which implies mutation, but the description doesn't add details about what happens during the update (e.g., whether it overwrites existing bids, atomicity, permission requirements). It mentions bulk support and partial_failure parameter but doesn't explain behavior like partial failure handling. Since annotations are minimal (no idempotent or destructive hints), the description carries more burden, but it falls short of explaining consequences or edge cases.

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 with two sentences, front-loaded with the primary purpose. It uses a line break to separate bulk support info, which is clear. However, the currency example could be omitted or expanded, but overall it's efficient without fluff.

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 6 parameters, no output schema, and minimal annotations, the description is incomplete. It doesn't explain return values, how to specify keywords (ad_group_id and criterion_id are required but not described), or the behavior of partial_failure. It covers bulk support but not the full context needed for correct invocation. The tool is relatively complex, so more detail is expected.

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 compensate for parameter meaning. The description explains 'cpc_bid' via currency example but doesn't explain the 'keywords' array structure (ad_group_id, criterion_id), 'partial_failure', or 'customer_id' vs 'customer_ids' distinction. It mentions bulk support but doesn't clarify required parameters or relationships. This is insufficient given zero schema coverage.

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

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

The description clearly states the action ('Update max CPC for one or more keywords') with a specific resource (keywords) and a specific attribute (max CPC). It distinguishes from siblings like 'google_ads_keyword_update_status' which updates status rather than bid. The example of account currency ('1.5 = R$1,50') adds useful context for understanding the value semantics.

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

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

The description provides some guidance on usage by indicating it supports bulk execution via customer_ids. However, it doesn't explicitly mention when to use this vs alternatives (e.g., when not to use, or mention of partial failure). It implies usage for updating bids but lacks exclusions or comparisons with sibling tools like google_ads_keyword_add or google_ads_keywords_diagnostics.

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

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

Annotations indicate readOnlyHint: false, destructiveHint: false, idempotentHint: false, which means the agent knows this is not read-only, not destructive in a dangerous way, and not idempotent. The description adds the bulk support detail (customer_ids) and the requirement for ad_group_id + criterion_id, which is useful. It does not mention failure modes or partial_failure behavior, but annotations already signal mutability. Since annotations are present and description adds some context, a 3 is fair.

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

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

The description is concise: two sentences. The first gives the main action and required fields, the second adds bulk support. It is front-loaded and avoids fluff. Not a 5 because it could be slightly more structured (e.g., a note about partial_failure), but overall it is efficient.

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

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

The tool has 6 parameters, no output schema, and annotations are minimal. The description explains the core functionality but doesn't cover all parameters (account, customer_id, partial_failure) or any return behavior. For a mutation tool with no output schema, it provides enough to invoke it correctly for basic use, but lacks detail on edge cases. It is adequate but not complete, so a 3.

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 compensate. It explains that 'keywords' array needs ad_group_id and criterion_id, which helps understand the required fields. It also mentions customer_ids for bulk. However, it does not explain the 'account', 'customer_id', or 'partial_failure' parameters. With 6 params and only partial explanation, the description adds some value but not complete. Baseline for low coverage would be lower, but the description covers the two most critical aspects, so 3.

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

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

The description clearly states the tool's purpose: 'Pause, enable or remove keywords.' It specifies the resource (keywords) and the actions (pause, enable, remove), which distinguishes it from sibling tools like google_ads_keyword_add (add) and google_ads_keyword_update_bid (update bid). It doesn't explicitly contrast with siblings, but the verb+resource is specific enough for a 4.

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 says 'Each entry needs ad_group_id + criterion_id' and mentions 'Bulk support: accepts customer_ids for batched execution.' This gives basic usage context but does not explicitly state when to use this tool vs alternatives (e.g., when to use google_ads_keyword_add vs this one). It implies you use it for status changes but lacks exclusions or alternative guidance, so a 3 is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description goes beyond annotations by explaining that it lists accessible customers beyond the MCC hierarchy, enriches results with specific fields, and supports bulk execution. This adds meaningful non-obvious 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 description is compact, front-loaded with the core purpose, and every sentence adds value. It packs the API method, scope caveat, enriched fields, cross-tool usage, and bulk support into two tight paragraphs with 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 enriched fields returned for each customer (descriptive_name, currency_code, time_zone, manager flag, status), which is essential for downstream use. With all parameters optional and safety annotations present, the description gives sufficient context for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description carries the full burden for parameter meaning. It explains `customer_id` as a 10-digit identifier to reuse in other tools, `account` as the MCC connection selector, and `customer_ids` for batched execution. All three parameters receive meaningful semantics despite the bare input 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 uses a specific verb ('List') with a clear resource ('all Google Ads MCCs and ALL customer accounts the OAuth token can access') and explicitly distinguishes this from a hierarchy-only listing by referencing customers:listAccessibleCustomers. It clearly differentiates from sibling tools by focusing on account enumeration rather than campaigns, ads, or 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 provides clear context on when the tool is useful: any time you need the full set of accessible customer accounts for an OAuth token. It also gives actionable guidance for downstream use of returned `customer_id` and `account` values, but it does not explicitly state when to prefer this over alternatives or when not to use it.

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

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

Annotations indicate this is a mutating operation (readOnlyHint=false), and the description confirms it adds keywords, but it does not disclose potential side effects, rate limits, or idempotency. Since annotations cover the mutation aspect, this is adequate.

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

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

The description is brief and front-loaded with the core action, then adds bulk support with a bullet point. It is efficient, though the bulk note is incomplete.

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 8 parameters, no output schema, and low annotation value, the description does not explain edge cases, error handling, or behavior for partial failures. It is too thin for a complex bulk-capable mutation 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?

Schema description coverage is 0%, and the description only mentions scope, target_id, and bulk fields (target_ids, customer_ids). It fails to explain the purpose of 'account', 'keywords' nested structure, 'partial_failure', or how the bulk execution works beyond mentioning acceptance.

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 it adds negative keywords at campaign or ad group scope, using a specific verb and resource. While it doesn't reference sibling tools explicitly, the scope of negative keywords is distinct from other keyword tools in the list.

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 specifying scope and target_id, but does not contrast with alternatives like google_ads_keyword_add or provide guidance on when to choose this tool over others. It gives minimal context on prerequisites or context.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context by noting the daily aggregation and the bulk batch execution capability through customer_ids, which are not captured in annotations.

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

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

The description is extremely concise, front-loading the primary purpose in the first sentence and the bulk support detail in the second. Every word adds value with no repetition or fluff.

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 lists expected metrics and bulk support, giving a good sense of output contents, but without an output schema or further details on parameter semantics, date handling, or account selection, some ambiguity remains. It is adequate but not thorough for a four-parameter 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?

Schema description coverage is 0%, so the description must compensate, but it only partially does. It clarifies that customer_ids enables batched execution and that days relates to the daily breakdown, but it leaves 'account' and 'customer_id' unexplained and does not clarify their relationship or which to use when.

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 provides a 'daily performance breakdown' with specific metrics (cost, impressions, clicks, conversions, revenue), making its core purpose obvious. It differentiates from sibling tools like google_ads_today or google_ads_campaigns by emphasizing daily aggregation, though it lacks an explicit action verb like 'retrieve' or 'list.'

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 daily performance data and bulk execution via customer_ids, giving a basic sense of when to use it. However, it does not explicitly contrast with sibling tools such as google_ads_campaigns or google_ads_today, nor does it explain when one input should be preferred over another (account vs customer_id).

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

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

The description adds meaningful behavioral context beyond annotations: default status PAUSED, bulk execution support via ad_group_ids/customer_ids, and validation limits for headlines/descriptions. Annotations already indicate this is a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The added defaults and bulk behavior are useful and not contradictory.

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 core purpose and constraints, the second covers the default status, and the third describes bulk support. Every sentence carries useful information without redundancy or fluff.

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 11 parameters and no output schema, the description covers the most critical creation requirements (headline/description limits, final_urls, default status, bulk mode) but omits details on optional parameters like path1/path2, account, and customer_id. It also does not mention success/error behavior. Adequate for basic invocation but incomplete for full parameter understanding.

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 compensate. It does explain headlines (3-15, <=30 chars), descriptions (2-4, <=90 chars), final_urls required, and default status PAUSED. However, it leaves several parameters unexplained (path1, path2, account, customer_id) and only hints at ad_group_ids/customer_ids via the bulk support line. This is partial compensation for a tool with 11 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 states the action ('Create a Responsive Search Ad (RSA)') and the target resource ('inside an ad group'). It includes specific constraints (headline/description counts and character limits) that distinguish it from other sibling creation tools like ad_group_create or campaign_create. The verb+resource+scope make the purpose unambiguous.

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

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

The description provides clear context for when to use the tool: to create an RSA within an ad group, with required fields and default behavior ('Default status PAUSED'). It also mentions bulk support for batched execution. It does not explicitly name alternatives or exclusion criteria, but the sibling set makes the context 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?

Annotations already cover the read-only, idempotent, non-destructive nature, so the description appropriately adds behavioral context beyond them: the default current-month date window, per-campaign output breakdown, _summary inclusion, and batched execution support. It stops short of describing response formatting or potential API-side limits, but the important behavior is conveyed.

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 short and front-loaded: the first line names the core computation and default, the second captures output structure, and the third adds batching semantics. There is no wasted prose except very minor redundancy in 'bulk support' and 'bulk execution,' but it is still concise and scannable.

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

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

With no output schema and an otherwise bare parameter schema, the description should clarify singular vs. plural account identifiers and when to use them; it does not. It delivers enough high-level meaning for selecting the tool, but invoking it correctly for a single account may still be ambiguous between account, customer_id, and customer_ids.

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%, and the input schema provides only bare parameter names. The description adds just a little semantics by mentioning date-range and customer_ids for bulk, but leaves since, until, account, and customer_id unexplained. Given the low schema coverage, the description does not compensate enough for five 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 the resource (ROAS) and scope (a date range, defaulting to current month), and enumerates the returned data dimensions: per-campaign cost, conversions, revenue, and _summary. It lacks an explicit verb like 'returns' or 'fetches,' and it does not directly contrast itself with sibling tools such as google_ads_performance, but the purpose is still clear.

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

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

The description provides useful context: date range default and bulk support via customer_ids, implying when the tool should be used. However, it does not explicitly mention when to avoid it or which alternatives to use, such as google_ads_performance or google_ads_today, so the usage guidance remains implied rather than explicit.

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

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

Annotations are all false and provide no meaningful safety or idempotency context, so the description carries the burden. It discloses key side effects: created assets are 'shared in the account library,' it supports batched execution, and it clarifies that sitelinks are not display paths. It does not mention output/return values or idempotency, but covers the main behavioral traits well.

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

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

The description is well-structured, front-loaded with the core purpose, and every sentence adds value. It efficiently packs scope, asset semantics, validation constraints, display-path clarification, and bulk support into a compact but readable format.

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 mutation tool with no output schema and no positive annotation support, the description is unusually complete: it covers purpose, scoping, asset structure, constraints, account-library sharing, and bulk execution. It stops short of explaining partial_failure semantics and expected response/error behavior, but overall it is strong for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain scope enum values, sitelinks fields (link_text, final_url, description1/description2), validation limits, and bulk arrays (target_ids, customer_ids). However, parameters such as account, target_id, customer_id, and partial_failure are left unexplained, leaving gaps for a tool with 8 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 opens with a specific verb and resource: 'Create sitelink extensions and attach them to a campaign (default), the whole account (scope=customer) or an ad group.' It clearly defines the tool's scope options and distinguishes it from related concepts such as the ad's display path, and from sibling tools like google_ads_sitelinks and google_ads_sitelink_remove.

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

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

The description provides clear context for when to use the tool, including scope selection ('campaign (default)', 'scope=customer', 'ad group') and important practical guidance such as 'Google needs at least ~2 sitelinks to actually show them.' It does not explicitly list alternatives or exclusions, but the sibling names and the create-specific verbs make the usage boundary inferable.

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 that only the association is removed, the asset remains in the library, and the operation is reversible. This directly addresses the side effects and aligns with the destructiveHint=false annotation, providing clear transparency about the impact.

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

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

The description is concise, two sentences, with the main purpose front-loaded and additional details (reversibility, bulk support) neatly appended. No unnecessary elaboration.

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 lack of output schema and 5 parameters, the description provides sufficient context for the core functionality and key parameter usage. It does not explain return values or error handling, but for a mutation tool with reversible effects, the provided context is adequate.

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 description explains link_resource_names (source) and customer_ids (bulk usage), but does not elaborate on account, customer_id, or partial_failure. Since schema descriptions are absent, the description only partially compensates for parameter meaning; some parameters remain ambiguous.

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

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

The description clearly states the action (detach sitelinks) and the target resources (campaign/account/ad group). It distinguishes from related tools like google_ads_sitelink_create and google_ads_sitelinks by specifying removal and the source of link_resource_names.

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

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

It explains when to use the tool (to detach sitelinks), how to obtain the required link_resource_names (from google_ads_sitelinks), and mentions bulk support via customer_ids. However, it does not explicitly state when not to use it or mention alternative tools for deletion of assets.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral detail beyond annotations: it lists the output fields (resource_name, status), attachment scoping, and bulk execution capability. It does not mention pagination or max batch size, but this is acceptable given annotation coverage.

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

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

Two short paragraphs are well-structured and concise. The action is front-loaded, and each sentence provides meaningful information: listing behavior, output fields, use case, and bulk support. No redundant filler.

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

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

The description is informative for a read-only list tool with good annotations: it covers output fields and usage intent. However, the ambiguity of account vs customer_id and the lack of any mention of pagination or result shape (with no output schema) leave some gaps. It is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains customer_ids ('Bulk support: accepts customer_ids for batched execution'). The distinction between account and customer_id is left unclear, and no other parameter guidance is provided. This is a significant gap for a 3-parameter tool.

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 it lists sitelink assets, their attachment levels, resource_name, and status. It distinguishes itself from sibling tools like google_ads_sitelink_create and google_ads_sitelink_remove by framing this as an audit/listing action.

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?

Explicit guidance is given: 'Use to audit existing sitelinks before creating new ones.' This indicates the intended context and separates it from creation/removal tools. It also notes bulk support via customer_ids, though it does not detail exclusions or alternative tools.

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

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

Annotations already convey read-only and idempotent behavior, so the description correctly focuses on additive details: the dual-mode scoping (MCC vs. customer), the optional customer_id behavior, and the batch execution path. The batch semantics and conditional scope switching are meaningful behavioral disclosures beyond what the annotations declare, though no output/return format is mentioned.

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 tight, information-dense sentences. The first sentence fronts the most important distinction (with/without account scope), the second enriches with the optional customer_id behavior, and the third covers the bulk-use case. Zero filler words and each clause adds new information.

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

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

For a read-only status tool with 3 optional parameters and no output schema, the description covers the key decision space: the two operating scopes and the bulk path. It's held back slightly by not defining what 'details' means or any output shape, but given the readOnly/idempotent annotations and the simple parameter list, this is close to a complete picture.

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?

With a 0% schema description coverage, the description carries the full burden of explaining parameters, and it largely succeeds: 'account' toggles scope (implied by 'With/Without account'), 'customer_id' is established as optional for scoped details, and 'customer_ids' enables bulk operations. The only gap is that the account parameter isn't explicitly named (e.g., with backticks) and the parameter formats/constraints aren't specified, but for three all-optional params, this is solid compensation.

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 provides status overviews at two scopes (MCC-level overview vs. account-specific details) using a specific conditional structure (without/with 'account'). It differentiates reasonably from siblings like google_ads_account and google_ads_performance by focusing on status/overview at the account level; however, it never explicitly says what 'status' conceptually is (e.g., connectivity, campaign health) and doesn't differentiate from the similarly-scoped google_ads_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 explains the two invocation modes (no account for MCC-wide overview, with account/customer_id for scoped details) and notes bulk execution via customer_ids, which tells the agent how to select parameters. However, it never names alternatives or explains when to choose a sibling over this tool (e.g., when to use google_ads_performance or google_ads_account instead).

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

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

Annotations already declare readOnly and idempotent behavior. The description adds useful context by disclosing the output scope (per campaign plus _summary) and batched execution via customer_ids, which goes beyond the annotations.

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

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

The description is two concise sentences with no filler or redundancy. Front-loaded with the core purpose and followed by the bulk support detail, it earns every 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 read-only summary tool, the description covers core metrics and batch capability, but it omits details like timezone/scheduling for 'today' and how account/customer_id/customer_ids interact. The lack of an output schema heightens the need for such parameter-scoping information.

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?

With schema description coverage of 0%, the description must compensate for under-documented parameters. It only explains that customer_ids is for batched execution; it does not clarify the distinction or relationship between account, customer_id, customer_ids, or whether any are required.

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 it returns today's Google Ads performance with specific metrics (cost, impressions, clicks, conversions, ROAS) per campaign plus a summary. The 'Today' qualifier and metric list distinguish it from broader sibling tools like google_ads_performance or google_ads_roas.

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 a helpful usage cue by noting bulk support for customer_ids, implying it can be used for batched execution. However, it does not explicitly state when to prefer this tool over alternatives like google_ads_performance or google_ads_campaigns, nor does it mention 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?

The description adds significant behavioral context beyond annotations: it explains that invoke works even when the MCP is not installed, notes that permissions (workspace owner/admin) are required for writes, and describes the behavior of returning connect/checkout links when credentials or payment are needed. This directly supplements the sparse annotations (readOnlyHint=false, etc.) and does not contradict them.

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 long but dense, covering the full scope of the tool without redundancy. It is structured logically (core flow, key point, extensions like prompt library). While lengthy, every sentence contributes actionable information; it could be considered verbose, but not wasteful. It is appropriately front-loaded with the core concept.

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

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

Given the tool's complexity (multiple actions, 23 params), the description covers the main use cases and explains the overall workflow, permissions, and special behaviors. However, it omits details for some actions (e.g., resume, immediate, tier_slug) and does not outline the exact input requirements for each action. Nevertheless, for a tool with such breadth, it is fairly complete, especially since there is no output schema to rely on.

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?

With 23 parameters and 0% schema description coverage, the description must compensate by explaining parameters. It explains the action enum and some key parameters (mcp_id, tool_id, query, arguments), but leaves many others unexplained (limit, immediate, tier_slug, prompt_*, etc.). It does not detail required inputs for each action or how to format arguments, leaving significant ambiguity for correct invocation.

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 the official mcp.ai marketplace, covering both catalog discovery and execution of MCPs. It explicitly names the core actions (search, describe, invoke, install, etc.) and distinguishes from sibling tools (Google Ads specific) by focusing on the marketplace and prompt library. The purpose is unambiguous and concrete.

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 an explicit core flow (search → describe → invoke) and clear guidance on when to use invoke (temporary, one-off) vs install (permanent addition to toolkit). It also explains when to use actions like request_mcp, subscribe/cancel, and the prompt library functions. Alternatives are explicitly mentioned (e.g., prefer invoke over install for occasional use).

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

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

The description does not contradict annotations (idempotentHint true, readOnlyHint false). It adds that the conversation array is for reproduction, which gives some insight into behavior. However, it doesn't disclose potential side effects or data transmission, but with idempotentHint true this is less critical. Overall, minimal additional info beyond annotations.

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

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

The description is concise, two sentences, front-loaded with the purpose. No fluff, directly tells what to do.

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 it's a simple tool with 3 params and no output schema, the description covers the main use but leaves 'message' and 'context' unexplained. It's adequate but not thorough.

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%. The description only mentions the 'conversation' parameter implicitly by saying to include itgang. It does not explain the 'message' or 'context' parameters. Given the low coverage, the description should compensate but fails to fully do so.

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

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

The description clearly states the tool's purpose: 'Report a bug, missing feature, or send feedback.' This uses specific verbs and resource, and it's distinct from all sibling tools which relate to Google Ads operations. It unambiguously identifies this as the reporting/feedback tool.

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 explicit guidance: 'Include the conversation array with recent messages for reproduction.' This tells the agent what to provide when using the tool. It doesn't explicitly say when not to use it, but since it's the only feedback tool among siblings, it's clear to use for bug reports/feedback. No exclusions stated, but context is given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, non-mutating operation. The description adds the specific content (MCP platform and adapter versions) but does not disclose any additional behavioral traits such as output format, potential errors, or whether it requires authentication. Given the annotations cover the safety profile, a 3 is appropriate.

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

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

The description is a single, concise sentence that fully conveys the purpose. There is zero waste, and it is appropriately front-loaded. It earns its place perfectly.

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

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

Given the tool's simplicity (no parameters, no output schema, and clear annotations), the description is complete enough. It tells the agent exactly what information will be returned (versions). It could mention whether the output is a string or structured data, but with no output schema, the description does not need to explain return values in detail. The tool is simple, and the description covers the essentials.

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 schema description coverage is 100% (since there are no properties). The description adds meaning by specifying what versions are shown (MCP platform and adapter), which is useful context beyond the empty schema. With no parameters, the baseline is 4, and the description meets that 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 clearly states the tool's purpose: showing current MCP platform and adapter versions. It uses a specific verb ('show') and resource ('versions'), and it distinguishes itself from sibling tools like 'toolkit_info' by specifying the exact content (MCP platform and adapter versions). However, it could be slightly more explicit about what 'adapter' refers to in this context.

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

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

The description implies usage: when you need to check version information. However, it does not explicitly state when to use this tool versus alternatives like 'toolkit_info' or 'google_ads_status'. There is no mention of when not to use it or any prerequisites. The context is clear but lacks explicit guidance on alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by specifying exactly what the tool returns (installed MCPs, connection status, accounts, catalog tool counts). This goes beyond the annotations and clarifies the output content, though it doesn't mention potential performance or data volume.

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 that is front-loaded with the main purpose, then lists the specific components returned. There is no filler or redundant phrasing. Every word contributes to the clarity of the tool's function.

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 simplicity of the tool (no parameters, no output schema, low complexity), the description is sufficiently complete. It covers the primary output aspects: installed MCPs, connection status, accounts, and catalog tool counts. The annotations provide the safety profile, so no further behavioral disclosure is needed.

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

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

The tool has zero parameters, so the baseline is 4. The description doesn't need to explain parameters, and the schema coverage is effectively 100% since there are no properties. No additional parameter semantics are required.

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 returns the current toolkit state, specifying components: installed MCPs, connection status, accounts, and catalog tool counts. This distinguishes it from sibling tools which are Google Ads specific operations. The verb 'Returns' and resource 'current toolkit state' are precise.

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

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

The description does not explicitly state when to use this tool versus alternatives. While it is implied that one would use it to inspect the toolkit state before performing operations, there is no explicit guidance on exclusions or comparisons with tools like 'connect' or 'authenticate'. The context is clear but lacks direct instruction.

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