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

Annotations indicate non-destructive and non-readonly. The description adds that it returns a PREVIEW and requires confirmation, providing behavioral context beyond annotations. However, it does not disclose details like expiration of drafts or resource consumption.

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 short sentences plus a match_type line, each providing essential information. The purpose is front-loaded with 'returns a PREVIEW', and no unnecessary words. 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 (4 params, 2 required) and presence of output schema, the description explains the workflow and purpose well. It ties to sibling tools ('confirm_and_apply'). Minor gaps: no details on plan_id format or error handling, but sufficient for a drafting 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. It explains match_type values ('EXACT', 'PHRASE', 'BROAD') and the purpose of negative keywords, but does not describe the format of keywords or the customer_id parameter. The baseline for 0% coverage is 4, but the lack of detail on required parameters (campaign_id, keywords) reduces the score.

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 drafts negative keyword additions and returns a preview, with a specific verb ('Draft'). It distinguishes from sibling tools like 'add_to_negative_keyword_list' (direct addition) and 'propose_negative_keyword_list' (proposal), and references the follow-up tool 'confirm_and_apply'.

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 instructs to call 'confirm_and_apply' with the returned plan_id to execute, establishing a clear two-step workflow. It implies using this tool for preview before application, but does not explicitly state when not to use it or list alternatives like direct addition.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating a safe read operation. The description adds behavioral insights like revealing click-to-session ratios as a GDPR indicator and computing cost-per-GA4-conversion. It does not contradict annotations and provides useful context beyond the annotations, such as date format and default behavior.

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

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

The description is relatively concise, with five sentences covering the core conversion mapping, key outputs, and date format. It is front-loaded with the main purpose and avoids unnecessary details. Every sentence adds value, though the structure could be slightly improved by grouping related concepts (e.g., output details).

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

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

Given the tool's complexity (5 parameters, output schema exists), the description covers the main purpose and several key outputs (click-to-session ratios, cost-per-GA4-conversion, non-paid conversion rates). It does not need to explain return values due to output schema. However, it could be more complete by mentioning default behaviors for parameters other than dates and required permissions.

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 date_format for the two date parameters (e.g., 'YYYY-MM-DD', empty = last 30 days). It does not describe customer_id, property_id, or campaign_name, leaving ambiguity about their purpose. This is insufficient for a 5-parameter tool with no parameter descriptions elsewhere.

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 maps Google Ads campaign clicks to GA4 conversions and computes cost-per-GA4-conversion, click-to-session ratios, and non-paid conversion rates. It distinguishes itself from sibling tools like get_campaign_performance (which only retrieves campaign metrics) and attribution_check (which may focus on attribution models) by specifying cross-platform integration and unique outputs.

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

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

The description provides clear context on when to use the tool (for analyzing click-to-conversion mapping, GDPR indicators, and comparing Ads vs. GA4 conversions). It mentions non-paid channel rates for context but does not explicitly state when not to use it or suggest alternatives. This is adequate but lacks formal exclusions.

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

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

Annotations already indicate read-only and non-destructive. The description adds value by detailing the analysis scope (consent gaps, attribution models) and behavior of the conversion_events parameter. No contradictions.

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 front-loaded with purpose, then specific diagnoses, then parameter details. It is concise (5-6 lines) with no fluff, though could group related points.

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 an output schema present, return values need not be explained. The description covers main behavioral aspects and key parameter semantics, but omits context for customer_id and property_id. Reasonably complete for an analysis 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. It explains conversion_events (optional list vs aggregate) and date format/empty default, but does not explain customer_id or property_id. Adds partial value.

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 compares Ads-reported conversions to GA4 to find tracking discrepancies, with specific diagnoses (GDPR consent gaps, attribution model differences, missing events). This distinguishes it from sibling analysis tools like validate_tracking or analyze_campaign_conversions.

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

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

It provides clear context for when to use (comparing Ads vs GA4, diagnosing specific issues) but does not explicitly mention when not to use or contrast with alternatives like get_tracking_events or analyze_campaign_conversions.

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 indicate readOnlyHint=false and destructiveHint=false. The description adds significant behavioral details: the operation is non-destructive to the shared set itself, only removes attachments, and returns a preview that requires confirmation. This fully informs the agent about the tool's behavior and side effects.

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

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

The description is concise and well-structured: a one-line summary, followed by behavior, usage guidance, and parameter definitions. Every sentence adds value, no redundancy. It uses clear language and efficient formatting.

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 moderate complexity and the presence of an output schema (returning a preview), the description covers all necessary aspects: what the tool does, how to use it, the preview and confirmation workflow, and the source of parameter values. It is complete for the agent to understand and use 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 must explain parameters. It clearly defines shared_set_id (numeric ID from get_negative_keyword_lists) and campaign_ids (list of numeric campaign IDs). However, the optional customer_id parameter is not mentioned, which is a minor gap. Overall, it adds substantial meaning 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 action: 'Detach a shared set from one or more campaigns'. It specifies the resource (shared set) and the scope (from campaigns), and distinguishes it from the sibling `attach_shared_set_to_campaigns`. It also clarifies that the shared set remains unchanged, 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 explains when to use the tool (to remove CampaignSharedSet linkages) and provides explicit pre-requisites: 'Use get_negative_keyword_list_campaigns to inspect existing attachments before detaching.' It also notes that the operation returns a preview and requires a follow-up call to confirm_and_apply, giving clear usage 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 indicate non-read-only and non-destructive behavior. The description adds that it returns a preview and does not create, which aligns with the annotations. It also notes the ad group is ENABLED and SEARCH_STANDARD, providing useful behavioral context beyond 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 brief (a few sentences) with bullet points for parameters. It front-loads the key information about the preview nature and the workflow. Every sentence adds value with no redundancy.

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

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

The description covers the tool's purpose, parameters, and the necessary next step (confirm_and_apply). With an output schema available, the lack of detail on the return value is acceptable. Overall, it provides sufficient context for an agent to use 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 compensates by explaining each parameter's purpose and format: campaign_id source, ad_group_name, keywords structure (list of objects with text and match_type), and cpc_bid_micros condition. The customer_id parameter is not explained, but it has a default value.

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 drafts an ad group and returns a preview, not a creation. It distinguishes itself from sibling tools like confirm_and_apply by specifying the draft-then-execute workflow. The ad group type and status are explicitly mentioned.

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 indicates the draft is a preliminary step before calling confirm_and_apply, providing clear context on when to use this tool and what to do next. However, it does not explicitly list alternative tools or scenarios where this should not be used.

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 not read-only and not destructive. The description adds that the tool drafts and returns a preview, requiring confirmation via another tool. It also explains the effect of the negative flag and the fixed nature of Google's age buckets.

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 with clear sections and front-loaded purpose. It is somewhat lengthy but every sentence adds necessary value. Minor redundancy could be trimmed.

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 existence of an output schema (implied), the description adequately covers the tool's behavior, parameters, constraints, and follow-up step (confirm_and_apply). No gaps are evident for an AI agent to use 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%, but the description fully compensates by explaining each parameter: negative flag, ad_group_id vs campaign_id, and accepted values for age_ranges, genders, parental_statuses, income_ranges. It also notes constraints like at least one demographic list must be non-empty.

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 drafts demographic targeting criteria and returns a preview. It distinguishes from siblings like get_demographic_targeting (which retrieves existing) and confirm_and_apply (which executes the draft).

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 when to use the tool (to exclude or narrow demographic segments) and provides constraints like providing exactly one of ad_group_id or campaign_id. It also directs to confirm_and_apply for execution. However, it does not explicitly state when not to use this tool.

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

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

Annotations (readOnlyHint: false, destructiveHint: false) are basic. Description adds crucial behavior: returns a PREVIEW, does NOT add keywords, requires confirm_and_apply. Discloses the two-step process and non-destructive nature.

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

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

Two sentences, front-loaded with purpose. Every sentence adds value: first states what it does, second details keyword format and follow-up action. No wasted words.

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?

Covers the main behavior, return value (plan_id), and required follow-up tool. Could have explained optional customer_id parameter, but overall complete given the tool's simplicity and presence of output schema.

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

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

Schema coverage is 0%. Description only explains the 'keywords' parameter format with examples, but does not clarify 'ad_group_id' or 'customer_id'. Partially compensates for lack of schema 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?

Clearly states action ('draft') and resource ('keyword additions'), explicitly says it returns a preview and does NOT add keywords. Distinguishes from sibling tools like 'add_negative_keywords' by indicating it's a preparatory step.

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

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

Provides explicit instruction to call confirm_and_apply to execute, and specifies that it does not add keywords. However, it doesn't elaborate on when to use this tool versus other sibling tools beyond the follow-up step.

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?

Description states non-destructive (does NOT create ad), but annotations readOnlyHint=false suggests possible side effects (e.g., saving draft). Not fully transparent about whether draft is stored or purely computed. Adds context but does not resolve the ambiguity.

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?

Well-structured: purpose first, then input details, then examples. Each sentence adds value. Slightly verbose but efficient overall.

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?

Covers purpose, input format, constraints, and next step. Output schema exists, so return value not needed. Lacks edge cases (e.g., what if headlines count invalid) but sufficient for a drafting 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 0% so description carries burden. Explains headlines/descriptions structure (plain string vs dict with pinning), valid pin values, and Google caps. Provides significant meaning beyond schema. Does not explain ad_group_id, final_url, or customer_id, but those are relatively self-explanatory.

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

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

Clearly states the verb 'draft' and resource 'Responsive Search Ad', with explicit distinction from creation: 'returns a PREVIEW, does NOT create the ad'. Distinguishes from sibling 'confirm_and_apply'.

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

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

Provides clear when-to-use (drafting preview) and explicit next step ('Call confirm_and_apply to execute'). Gives constraints (headlines 3-15, descriptions 2-4, character limits, pinning rules). Lacks explicit when-not-to-use or alternatives, but guidance is strong.

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 set readOnlyHint=false and destructiveHint=false. The description adds that the tool 'returns a PREVIEW' and requires a follow-up call to execute. This clarifies the non-destructive, non-read-only nature and provides behavioral context beyond annotations. No contradiction found.

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 well-structured. It starts with a clear one-line purpose, then uses a bullet-like list for the sitelinks structure. No redundant sentences. 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?

Covers the main purpose, parameter details (except customer_id), usage context, recommendations, and next steps. Has an output schema, so return value explanation is not needed per rules. Lacks explanation of customer_id but otherwise complete for a drafting tool with preview.

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 bears full burden. It explains the sitelinks parameter in detail with sub-fields (link_text, final_url, description1, description2) and constraints (max chars). However, it does not explain the customer_id parameter (only default shown) or note that it's optional.

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 drafts sitelink extensions for a campaign and returns a preview. It uses specific verbs and resources (draft sitelinks, returns preview). However, it does not explicitly differentiate from sibling 'draft' tools like draft_callouts or draft_keywords, which share a similar draft-and-preview pattern.

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

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

Provides clear context: 'Call confirm_and_apply with the returned plan_id to execute.' Also includes a Google recommendation on minimum sitelinks (at least 4, fewer than 2 may not show). Does not explicitly state when not to use this tool or list alternatives, but the guidance is adequate for usage.

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

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

Annotations indicate it is not read-only (readOnlyHint: false) and not destructive (destructiveHint: false). The description adds that it returns a PREVIEW, implying no final creation or side effects, which is significant behavioral context 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 a single sentence containing essential information: action ('draft'), resource ('structured snippet assets'), and key outcome ('returns a PREVIEW'). It is concise and front-loaded, though adding minimal parameter context would not sacrifice brevity.

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

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

Given 3 parameters (2 required) with no schema descriptions, the description is incomplete. It does not explain the format of the 'snippets' array or the role of 'customer_id'. The existence of an output schema partially mitigates missing return info, but input semantics remain unclear.

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% with no descriptions for any parameter. The description only names the tool's purpose and does not explain the structure or constraints for 'snippets' or the optional 'customer_id', leaving the agent to infer from parameter names alone.

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

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

The description clearly states it drafts structured snippet assets for a campaign and returns a preview. It distinguishes itself from sibling draft tools (e.g., draft_callouts, draft_sitelinks) by specifying 'structured snippet assets', making the purpose unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives like draft_callouts or draft_sitelinks. No context for prerequisites or when to choose this over other drafting tools 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 indicate readOnlyHint=false (mutation) and destructiveHint=false (not destructive). The description adds transparency by explaining that it is a draft/preview that returns a plan_id, requiring a subsequent call to confirm_and_apply to execute. This clarifies that the action is not immediate.

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 reasonably concise and front-loaded with the main purpose. It uses a structured format for entity types and ID formats. A bit more compactness could be achieved, but it is clear without unnecessary text.

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

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

Given the existence of an output schema (not shown), the description does not need to explain return values. It covers the core functionality, including entity types and ID formats. However, it could mention error conditions (e.g., if entity is not paused) for full 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?

Schema coverage is 0%, so the description fully compensates. It explains entity_type with allowed values, entity_id with format per type (with examples), and customer_id as optional. This is essential for correct parameter usage.

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 is for drafting an enable action on paused entities (campaigns, ad groups, ads, keywords) and returns a preview. It distinguishes itself from siblings like pause_entity and remove_entity by specifying the action and workflow.

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

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

The description provides a clear workflow: call to get a preview, then use confirm_and_apply to execute. It also explains entity types and ID formats. However, it does not explicitly state when not to use it (e.g., if the entity is already enabled or if immediate action is needed).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds behavioral context by explaining the compact mode: it returns totals, top-10 ads with counts, and findings, and notes the size reduction (~90% smaller). This goes 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 (three sentences) and front-loaded: first sentence states purpose, second lists return fields, third details compact mode. No redundant information, though the list of return fields could be integrated into the first sentence minimally.

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 output schema exists, the description covers return values adequately. It also details compact mode behavior. However, it lacks documentation for three parameters and does not differentiate well from sibling tools (e.g., get_asset_performance) in the context of comprehensive performance analysis.

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 only explains the 'compact' parameter and its effect. The remaining three parameters (customer_id, date_range_end, date_range_start) are not described at all, leaving the agent without guidance on their usage or format.

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 'Get ad-level performance data' which is a specific verb+resource. It lists the fields returned, distinguishing it from other performance tools like get_campaign_performance or get_keyword_performance. However, it doesn't explicitly differentiate from sibling tools like get_asset_performance, leaving some ambiguity.

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

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

The description provides guidance on when to use compact=true ('for audits/overviews') and the benefits. However, it does not specify when to avoid the tool or mention alternatives among siblings, such as get_ad_performance vs get_detailed_asset_performance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds value by specifying return fields (field_type, primary_status, content), noting the inclusion of summaries, and disclosing that per-asset performance labels are unavailable for PMax assets. No contradiction 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?

Description is concise with three well-structured paragraphs. Purpose and return fields are front-loaded. No unnecessary words or repetition. Efficient use of space.

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

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

Given the tool's simplicity (two optional params, output schema exists, read-only), the description is mostly complete. It covers purpose, return fields, limitations, and alternative tool. The only gap is the lack of explanation for the customer_id parameter, which is typical in Google Ads tools.

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

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

Schema coverage is 0% (no parameter descriptions in schema). Description only explains campaign_id as an optional filter to a single PMax campaign, but does not mention customer_id at all. Partial compensation for missing schema 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?

Description clearly states it gets per-asset details for PMax campaigns (specific verb+resource+scope). It explicitly differentiates from sibling get_detailed_asset_performance by noting the limitation on performance labels and pointing to the sibling for proxy quality data.

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

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

Description specifies when to use (to retrieve asset details for PMax campaigns) and explicitly advises against using it for performance labels (BEST/GOOD/LOW), suggesting an alternative tool (get_detailed_asset_performance) for proxy quality assessment.

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=true and destructiveHint=false. Description adds details on returned fields (value, negative/positive, status, remove_id) and how remove_id can be used with remove_entity. No contradictions.

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?

Four sentences, front-loaded with purpose, then constraints, then details. Every sentence adds value with no 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?

Output schema exists, and description explains return values and important behavioral note about default 'all segments'. Covers typical usage scenarios adequately.

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 description carries full burden. It explains the mutual exclusivity constraint for ad_group_id and campaign_id, which is not in schema. Customer_id is not explained but is standard. Adds meaning beyond schema.

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

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

The description clearly states it lists demographic targeting criteria (age, gender, parental status, income) and explains the condition of using exactly one ID. It is specific and distinguishes from siblings like draft_demographic_targeting.

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 requires exactly one of ad_group_id or campaign_id, and provides key context that criteria only appear when actively excluded or narrowed. Lacks explicit when-not-to-use but context is sufficient.

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 readOnlyHint=true. Description adds that the tool returns asset combinations with field types, providing behavioral context beyond annotations. No contradictions.

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?

Description is concise (about 5 sentences) with front-loaded purpose, then output details, use case, and parameter explanation. No unnecessary words.

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 tool with two optional params and output schema, description is nearly complete. Lacks explanation of customer_id, but overall covers purpose, output, and one filter.

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 description must explain parameters. It explains campaign_id as an optional filter but does not mention customer_id, leaving it undocumented. Thus, only partial semantic addition.

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 the tool gets top-performing asset combinations for Performance Max campaigns, specifying headline + description + image combinations. This distinguishes it from siblings like 'get_asset_performance' (individual asset stats) and 'get_pmax_performance' (overall campaign 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?

Description implies usage for creative optimization by showing which combinations Google selects most often. It provides context on what the data helps identify, but lacks explicit guidance on when not to use or alternatives among siblings.

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

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

Annotations already note readOnlyHint=true and destructiveHint=false. The description adds significant behavioral detail: 'Includes every parameter, firing/blocking triggers (with their filter conditions resolved to text), priority, pause status, sampling, and monitoring metadata.' This goes well beyond the annotations and accurately describes the output scope.

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

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

The description is concise: two sentences. The first sentence captures the core purpose, and the second lists key output components and a use case. Every word adds value, with no repetition or fluff. It is well-structured and front-loaded.

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

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

The tool has a low schema coverage (0%) but an existing output schema (implied). The description explains the tool's purpose and output contents comprehensively for a read-only operation. However, it does not cover the optional parameters or their context, leaving a small gap in 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?

The input schema has three parameters (tag_id required, optional gtm_account_id and gtm_container_id) but zero schema description coverage. The description does not explain what these parameters represent or how to use them. It only mentions the tool's overall purpose, adding no semantic value to the 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 'Get the full RAW configuration for a single GTM tag,' specifying the verb (get), resource (full RAW configuration), and target (single GTM tag). It distinguishes itself from sibling tools like list_gtm_tags (listing tags) and get_gtm_trigger (for triggers) by emphasizing 'full RAW configuration' including triggers, priority, etc.

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

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

The description provides a specific use case: 'Use to inspect a tag flagged by audit_event_coverage.' It implies deep inspection, though it does not explicitly state when not to use it or mention alternatives like list_gtm_tags for a summary. The guidance is clear but lacks exclusion criteria.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is clear. The description adds valuable context by detailing what the raw configuration includes (filters, validation settings, list of tags using the trigger), which goes beyond the annotations and helps the agent understand the behavior.

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

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

The description is two sentences long, front-loaded with the main action, and each sentence adds meaningful information. There is no redundancy or waste.

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 returns a full configuration, has an output schema, and has 3 parameters with 0% schema coverage, the description is partially complete. It explains the output content and use case but lacks parameter context and doesn't mention that the output schema exists. 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?

With 0% schema description coverage and 3 parameters, the description needs to compensate but only vaguely mentions 'a single GTM trigger' and 'specific trigger ID'. It does not explain the optional gtm_account_id and gtm_container_id parameters, their purpose, or default behavior. This is a significant 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 clearly states the tool gets the full RAW configuration for a single GTM trigger. It uses a specific verb ('Get') and resource ('full RAW configuration'), and it distinguishes itself from siblings like list_gtm_triggers (which lists all triggers) by focusing on a single trigger and including diagnostic purpose.

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

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

The description provides a clear use case: 'Use to diagnose why a tag with a specific trigger ID does or doesn't fire.' This gives context on when to use the tool, but it does not explicitly mention alternatives or when not to use it, so it's slightly less than a 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral detail: 'Product-status data lags reality by ~30 minutes' and mentions that critical account issues 'stop offers serving entirely,' providing context 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 (under 80 words) and well-structured: a clear first sentence naming the tool, followed by a detailed second sentence explaining outputs, and a final sentence specifying the parameter. No wasted words.

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 an output schema (not shown), the description sufficiently explains return values (counts per context, top product issues with links, account-level issues) and adds a critical timing caveat. It also references the source tool for the parameter, providing complete context for agent usage.

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

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

The input schema only specifies 'account_id' as a string with no description (0% coverage). The description adds: 'account_id: numeric Merchant Center ID from list_merchant_accounts,' clarifying the type, format, and source of the ID, which significantly enhances parameter understanding.

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: 'Merchant Center feed health — disapproved products + account issues.' It specifies what it surfaces (approved/pending/disapproved counts per context, top product issues with links, account-level issues) and distinguishes it from sibling tools by its unique focus on feed health.

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 on when to use the tool, e.g., to diagnose feed issues that 'silently starve Shopping and Performance Max campaigns.' It implies usage for feed health diagnostics but does not explicitly exclude alternatives or provide when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, so the description adds no additional behavioral context beyond stating it lists keywords. It does not disclose any side effects, authentication needs, or rate limits, which are already covered by 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 concise sentences: first states purpose, second explains the key parameter. No unnecessary words, well-structured and front-loaded.

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

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

Given the presence of an output schema and annotations covering read-only behavior, the description provides essential context. However, it omits details on pagination, filtering, or order of results, which would be helpful for a list tool but are not critical.

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 partially compensates by explaining shared_set_id as 'numeric ID from get_negative_keyword_lists (shared_set.id).' However, customer_id is left unexplained, leaving a 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 clearly states 'List the keywords inside a shared negative keyword list,' which is a specific verb and resource. It distinguishes from sibling tools like 'get_negative_keyword_lists' (which lists lists) and 'add_to_negative_keyword_list' (which adds keywords).

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

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

The description implies a prerequisite (shared_set_id from get_negative_keyword_lists) but does not explicitly state when to use this tool versus alternatives or provide exclusions. For a simple retrieval tool, this is minimally adequate but lacks clear guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating no side effects. The description adds detail on returned fields but does not cover pagination, authorization, or other behavioral traits. It adds moderate value beyond the annotations.

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

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

The description is three sentences, each serving a clear purpose: stating the action, listing return values, and providing usage guidance. It is concise and front-loaded with the most important information.

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

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

For a simple read tool with annotations and an output schema (not shown), the description covers the main action and return values. However, the lack of parameter documentation and limited sibling differentiation (only one sibling mentioned) leaves minor gaps. Overall, quite 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 schema has 0% description coverage for the sole parameter (customer_id), and the description does not mention the parameter at all. The agent has no guidance on its purpose or format, which is a significant 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 clearly states the tool lists shared negative keyword lists (SharedSets) and specifies the returned fields (ID, name, status, keyword count). It distinguishes itself from the sibling tool propose_negative_keyword_list by advising to call this first to avoid duplicates.

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 instructs to always call this tool before propose_negative_keyword_list to avoid creating duplicate lists, providing a clear usage context. It does not cover when to avoid or alternative tools, but the given guidance is strong for a key workflow step.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds the campaign_id behavior (empty returns all campaigns). However, it does not disclose other traits like pagination or rate limits.

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 sentences, each adding value: purpose, usage context, and parameter behavior. No unnecessary words, front-loaded.

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

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

The description covers the main functionality and usage, but omits explanation of the customer_id parameter. With an output schema present, return values are not needed, but parameter documentation is incomplete.

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

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

The description only explains the campaign_id parameter's behavior (empty returns all campaigns). The customer_id parameter is completely undocumented, and schema coverage is 0%, so the description does not compensate sufficiently.

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 existing negative keywords for a campaign or all campaigns, with a specific verb (list) and resource (negative keywords). It also provides usage context ('before adding') and distinguishes from sibling tools like add_negative_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 explicitly advises using this tool before adding negative keywords to check for duplicates, and explains behavior when campaign_id is empty. It lacks explicit exclusions but the context is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds that it returns status and actionable guidance, which is helpful.

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, no wasted words.

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

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

For a zero-parameter diagnostic tool with output schema, the description fully covers its operation and output.

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?

No parameters. The description adds value by explaining what it checks and the type of output (status per service, actionable guidance).

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 tests AdLoop connectivity for OAuth, GA4 API, and Google Ads API. It stands out from siblings as a diagnostic 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?

Explicitly advises to run this first when other tools are failing, providing clear when-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds context about combining ad final URLs with GA4 data and identifying specific issues (orphaned URLs), which goes beyond annotations. However, does not discuss data freshness, rate limits, or other behavioral traits. Adequate but not exceptional.

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

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

Four sentences, front-loaded with core purpose. Efficiently conveys key details with minimal waste. Could be slightly more structured but overall 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?

With output schema present, return values are covered. Description explains data sources and identification of key issues (zero conversions, orphaned URLs). For a read-only analysis tool, this is fairly complete, though more explicit prerequisites (e.g., required IDs) would improve 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?

Schema coverage is 0% (no descriptions in input schema). Description explains date format and default behavior but does not clarify customer_id or property_id fields. Only partial compensation for missing schema 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?

Description clearly states the verb 'analyze' and specific resource 'landing pages', with concrete outcomes like identifying converting vs non-converting pages, zero conversions, and orphaned URLs. Distinct from sibling tools like analyze_campaign_conversions or get_ad_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?

No explicit guidance on when to use this tool vs alternatives like analyze_campaign_conversions or get_ad_performance. The description implies use for landing page analysis with paid traffic, but lacks when-not-to-use or alternative suggestions.

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 read-only and non-destructive. The description adds behavioral details about the default cap of 200 and truncation handling, which goes 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, with each sentence adding value. It is front-loaded with the primary function and structured logically from purpose to behavioral details to usage guidance.

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 (one optional parameter, output schema exists), the description covers return values (names, IDs, status) and truncation behavior. No gaps for effective agent 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?

The single parameter 'limit' has no schema description (0% coverage). The description compensates by explaining the default cap and how to adjust the limit when results are truncated, adding meaningful context.

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

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

The description clearly states the tool lists accessible Google Ads accounts and returns names, IDs, and status. It explicitly differentiates from sibling tools like get_campaign_performance by advising not to enumerate for specific account targets.

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

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

Provides explicit guidance on when to use (listing accounts) and when not to (targeting a specific account, instead use other tools). Also instructs on handling truncation with a higher limit, offering a concrete example.

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

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

Annotations already mark it as read-only and non-destructive. The description adds that it returns site URL and permission level, providing behavioral context 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 two concise sentences: first states purpose, second adds usage and output summary. No wasted words, well front-loaded.

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

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

Given zero parameters, full annotations, and an output schema, the description covers purpose, usage context, and output details. Nothing missing for this simple 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?

There are no parameters, so the baseline is 4. The description doesn't need to add parameter info, and it correctly implies the tool requires no input.

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 'List all Google Search Console properties the authenticated user can access' with a specific verb and resource. It also distinguishes its role as a discovery step before running reports, differentiating it from siblings like run_gsc_report.

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 advises to use this first to discover site URLs before running search analytics reports, giving clear when-to-use guidance. It doesn't list alternatives or exclusions, but the context is sufficient.

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 readOnlyHint=true and destructiveHint=false. The description adds value by explicitly listing the return fields (container_id, public_id, name, usage context) and their relevance, going beyond the annotations. However, it does not mention pagination or limits, if any exist.

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

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

The description is very concise with two sentences, no wasted words, and front-loads the core action. The second sentence efficiently lists key return fields.

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 simple one-parameter tool with a read-only annotation and an output schema, the description is mostly complete. It lists return fields and hints at usage (for audit_event_coverage). Missing a brief explanation of the parameter, but overall 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?

Schema description coverage is 0%, so the description must explain the parameter, but it does not mention gtm_account_id at all. It fails to explain what the parameter is, how to obtain it, or its relation to sibling tools like list_gtm_accounts.

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 'List all containers under a GTM account', specifying the exact resource and action. It distinguishes itself from sibling tools by listing return fields and explicitly mentioning that container_id is needed by audit_event_coverage, which differentiates it from other list tools.

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

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

The description implicitly suggests use via mentioning container_id for audit_event_coverage, but explicitly does not state when to use this tool versus alternatives like list_gtm_accounts or list_gtm_tags. No usage exclusions or alternative recommendations are provided.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, ensuring safe read operations. The description adds value by specifying that the tool lists tags from the LIVE container (not draft/workspace) and enumerates the included fields (type, status, parsed parameters, etc.), which provides useful 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 two sentences long. The first sentence states the primary purpose, and the second adds detail on what each tag includes and a usage hint. Every word earns its place; 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?

Given the tool's simplicity (listing tags) and the presence of an output schema (which covers return values), the description sufficiently explains the tool's function and context. It addresses the scope (LIVE container) and provides relevant detail without needing further elaboration.

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 two optional parameters (gtm_account_id, gtm_container_id) with defaults, but schema description coverage is 0%. The description does not explain these parameters, their defaults, or how to find the IDs. Despite the names being somewhat self-explanatory, the lack of guidance leaves ambiguity, especially since the parameters are optional.

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 'List every tag in the LIVE GTM container' with a specific verb and resource. It details the information included per tag, distinguishing it from sibling tools like get_gtm_tag (single tag) and list_gtm_triggers (triggers).

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

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

The description provides a usage hint: 'Use after audit_event_coverage to inspect specific tags.' This gives context but does not explicitly mention alternative tools or when not to use it. The guidance is helpful but not comprehensive.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds that it reads the LIVE container and parses filter conditions to readable text, offering context 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 only two sentences, front-loaded with the core purpose, and every sentence adds value without unnecessary words.

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

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

While the output schema handles return values and annotations cover safety, the description omits parameter requirements, making it incomplete for a tool with two inputs and 0% schema coverage.

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%, and the description fails to mention the required parameters (gtm_account_id, gtm_container_id) or their usage, leaving a significant gap for parameter understanding.

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 every trigger in the LIVE GTM container, distinguishing it from sibling tools like get_gtm_trigger (single trigger) and other list 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 explicitly says to use it to diagnose tag firing issues on specific pages, providing a clear use case, though it does not explicitly exclude other scenarios.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, so the tool is safe and non-destructive. The description adds behavioral context by detailing data sources (live container vs workspace) and explaining why variables matter for triggers. It does not 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?

The description is four sentences long, each serving a purpose: stating the action, explaining sources, and providing motivation. There is no fluff, and it is front-loaded with the main purpose.

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

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

Given the presence of an output schema, the description does not need to cover return values. However, it lacks parameter explanation and usage examples. The explanation of variable sources is good, but the overall completeness is adequate but not excellent.

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 two parameters (gtm_account_id, gtm_container_id) with 0% schema description coverage. The description does not mention these parameters or explain their purpose/format. Without this, the agent must infer from context, which adds ambiguity.

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 GTM variables, distinguishing between custom and enabled built-in variables. It explains the sources (live container for custom, workspace's enabled-built-ins list for built-in). This definitively sets it apart from sibling tools like list_gtm_tags or list_gtm_triggers.

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

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

The description implies when to use the tool (to list variables for trigger reference) but does not explicitly state when not to use it or provide alternatives. Siblings exist such as get_gtm_trigger or list_gtm_tags, but no guidance is given on selecting between them.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds that it lists only published versions, returns headers with specific fields (version_id, name, entity counts), and implies timestamp information exists for correlation. No contradiction 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 two sentences, with the purpose stated directly in the first sentence and usage guidance in the second. No verbose or redundant language, excellent front-loading.

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 3 optional parameters and an output schema. Description explains return structure (headers) and suggests a workflow, but does not clarify how parameters affect results (e.g., filtering by account/container, pagination with page_size). Missing parameter explanations reduce 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?

Schema description coverage is 0% and the description does not explain parameters (page_size, gtm_account_id, gtm_container_id). Default values are present in schema but no guidance on their role or filtering behavior. The description fails to add necessary meaning beyond 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 lists published GTM version history, sorted newest first. It distinguishes from siblings like get_gtm_version which retrieves full version content.

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

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

The description provides a concrete use case: correlating a metric drop with a recent publish by fetching versions and then calling get_gtm_version for details. This explicitly guides when to use this tool versus 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 and destructiveHint=false, so the safety profile is clear. The description adds value by explaining that the tool discovers merchant IDs and distinguishes account types, which is useful behavioral context beyond the annotations.

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

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

Two sentences: the first states the core purpose, the second provides a usage hint and a distinguishing feature. No wasted words; 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 tool's simplicity (no parameters, read-only, output schema exists), the description is complete. It informs the agent that the output contains merchant IDs and account types, which is sufficient for invoking the tool correctly.

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

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

The input schema has no parameters (0), and schema description coverage is 100%. Baseline is 4, and the description does not need to add parameter information. It appropriately focuses on usage and output.

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

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

The description clearly states the verb ('list') and resource ('Google Merchant Center accounts the connected user can access'), and adds specificity by mentioning it distinguishes standalone from MCA accounts. This differentiates it from sibling tools like list_accounts or list_gsc_sites.

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 advises to 'Call first to discover merchant IDs for get_merchant_feed_health,' providing clear context for when to use the tool. While it does not mention when not to use it, the straightforward nature of a list tool with no parameters makes this acceptable.

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

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

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description reveals that the tool returns a PREVIEW, not a final action, and requires a separate call to confirm_and_apply to execute. It also specifies the entity_id format per type, which is crucial for correct usage. This adds significant 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?

The description is concise, well-structured, and front-loaded. It starts with the core action, then explains parameters with examples, and ends with the execution step. Every sentence is valuable and efficiently communicates the needed 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?

Given the tool's complexity (3 parameters, clear entity relationships, output schema exists), the description covers the essential aspects: what it does, how to specify entities, and the follow-up required. It could mention error cases or constraints, but for the scope, it is adequately 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?

With 0% schema description coverage, the description compensates by explaining entity_type and entity_id thoroughly, including format examples for each type. The customer_id parameter is not explained, but it is optional with a default. The description adds meaningful guidance 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 it drafts pausing a specific entity (campaign, ad group, ad, or keyword) and returns a preview. It uses specific verbs and resources, distinguishing from sibling tools like enable_entity or remove_entity. The format for entity_id per type is given, making the purpose unambiguous.

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

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

The description explains the two-step process: draft then call confirm_and_apply. It implicitly tells when to use this tool (to pause entities) and provides the follow-up action. However, it does not explicitly state when not to use it or list alternatives beyond the sibling list, which is provided contextually.

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 destructiveHint=true. Description adds that it is a draft action (preview), not directly executed, and requires confirmation. It also details entity_id formats for different types, providing additional 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?

Well-structured with clear sections: action, entity types/ids, warning, next steps. Could be slightly more concise but is effective.

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 existence of output schema, description adequately states return type (preview with plan_id) and mentions required next step. Also covers warnings and id formats. No gaps.

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

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

Schema coverage is 0%. Description compensates well by listing all valid entity_type values and providing detailed entity_id formats for each type. However, it does not explain the optional customer_id parameter.

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

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

Description clearly states it drafts removal of an entity and returns a preview. It explicitly lists supported entity types and distinguishes from pause_entity by noting irreversibility.

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 advises using pause_entity for temporary disabling instead of this irreversible removal. Also instructs to call confirm_and_apply with the returned plan_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?

Annotations already indicate read-only and non-destructive behavior. The description adds that the report is custom and explains default property_id usage, providing useful behavioral context 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 with two sentences and bullet-like lists for dimensions, metrics, and date formats. It is front-loaded with the main action. Could be slightly more organized but is not verbose.

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

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

Given the optional parameters and output schema present, the description provides sufficient context to use the tool. It lists common inputs but lacks details on output structure, though the output schema covers that.

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

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

Schema description coverage is 0%, so the description must compensate. It offers common dimensions/metrics and date formats but does not explain each parameter's role (e.g., limit, or that all parameters are optional). The added value is moderate.

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 runs a custom GA4 report with specified dimensions, metrics, and date range. It lists common dimensions and metrics, establishing it as specific to GA4 reporting, which distinguishes it from siblings like run_realtime_report or run_gaql.

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

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

The description provides guidance on date formats and default property_id behavior, implying usage context. However, it does not explicitly state when not to use this tool or compare with siblings like run_realtime_report for real-time needs.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. Description adds no further behavioral context such as rate limits or quota; it primarily explains parameters. No contradiction 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?

Description is well-structured with the main purpose first, followed by parameter details in a readable format. Slightly verbose but no unnecessary repetition; could be tightened into a list but overall effective.

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 (7 parameters, optional output schema), the description is complete. It covers all parameters, mentions return metrics, and fits within the sibling tool context. No obvious gaps.

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

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

Schema has 0% coverage, so description fully compensates by explaining all 7 parameters: site_url with example, dimensions with allowed values, date formats, search_type options, dimension_filter_groups with example JSON, and limit with default/max. Very thorough.

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 it runs a Google Search Console search analytics report, listing specific metrics. It distinguishes itself from sibling reporting tools like run_ga4_report and run_gaql by explicitly mentioning GSC and cross-referencing capabilities.

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

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

Provides specific use cases: diagnosing organic traffic drops, finding keyword opportunities, and cross-referencing with GA4 and Ads data. Does not explicitly state when not to use, but the use cases guide appropriate usage.

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

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

The description uses 'draft' to imply that changes are not immediately applied, adding behavioral context beyond annotations (readOnlyHint=false, destructiveHint=false). However, it does not explicitly state that confirmation is required, nor does it detail side effects like whether existing values are overwritten or merged.

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

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

The description is a single sentence with no redundancy. It is front-loaded with the verb and resource. However, it could be slightly more informative without losing 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?

For a tool that drafts an update with multiple optional parameters and requires confirmation via a sibling tool, the description lacks critical context about the draft lifecycle, the meaning of default values, and the output (likely a draft handle). It is insufficiently complete for effective agent 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 explain all parameters, but it only addresses ad_group_name and max_cpc via 'name and/or manual CPC bid'. It omits ad_group_id (required but not explained) and customer_id (default empty, purpose unclear). This leaves significant ambiguity for an agent.

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

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

The description clearly states the verb 'draft' and the resource 'ad group update', and specifies the aspects that can be updated (name and/or manual CPC bid). It is distinguishable from sibling tools like 'draft_ad_group' (which creates a new ad group) and 'update_campaign' (which updates campaigns), though it does not explicitly differentiate them.

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

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

No guidance is provided on when to use this tool vs alternatives such as 'draft_ad_group' or 'update_campaign'. The description does not mention that this is a non-finalizing draft requiring confirmation via 'confirm_and_apply', nor does it explain prerequisites or contexts.

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?

Discloses that the tool only produces a preview and does not apply changes, aligning with annotations (readOnlyHint=false, destructiveHint=false). Also explains that certain parameters (like geo_target_ids) replace all existing targets, providing deep behavioral insight.

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

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

Description is front-loaded with the crucial preview behavior, then systematically covers each parameter. While slightly lengthy due to parameter explanations, every sentence adds value and no extraneous content exists.

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 output schema exists, the description explains the return value (plan_id) and how to use it with confirm_and_apply. It also covers parameter interdependencies and replacement semantics, making the tool's behavior fully understandable.

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 fully compensates by explaining every parameter: campaign_id required, bidding_strategy enum options, conditional target_cpa and target_roas, daily_budget, geo_target_ids with common IDs, language_ids with common IDs, booleans for network settings, and max_cpc conditional. It even clarifies that display_expansion_enabled is an alias.

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 drafts an update to a campaign and returns a preview without applying it, with a specific verb and resource. It distinguishes the tool from the sibling 'confirm_and_apply' that executes the update.

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

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

Provides explicit guidance on when to use the tool (only include changed parameters) and directs the user to call 'confirm_and_apply' with the returned plan_id to execute. It also explains conditional parameter requirements (e.g., target_cpa needed if bidding_strategy is TARGET_CPA).

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