Kampalo

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds only scope context (which assistants are counted), but says nothing about filtering defaults, aggregation, or the practical effect of the 17 optional params. Adequate but thin for the annotation-assisted bar.

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

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

A single, front-loaded sentence with no filler; every word earns its place. It is perhaps too terse for the tool's complexity, but it is structurally clean.

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?

An output schema exists so return values needn't be explained, but for a 17-parameter analytics tool with no required params and no schema descriptions, the agent is left without filtering, date-range, or pagination semantics. The description does not close that gap.

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

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

The schema has 17 parameters at 0% description coverage, and the description offers zero information about any of them (url, date_from/date_to, days, limit, range_preset, activity_only, etc.). With such high parameter count and no schema or description guidance, the description fails entirely to compensate.

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

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

The description names the data source (GA4), the metric category (AI / AEO referrals), and concrete examples of the referrers (ChatGPT, Perplexity, Gemini), distinguishing it from general siblings like analytics_get_ga4_metrics. It lacks an explicit verb, but the resource is unambiguous enough for an agent to select it correctly.

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?

There is no guidance on when to use this tool versus analytics_get_ga4_metrics or analytics_get_organic_roi, nor any prerequisites or exclusions. Usage is only weakly implied by the 'AI/AEO referrals' scope.

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

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

Annotations already establish readOnlyHint=true and openWorldHint=false, so safety is covered. Beyond that the description adds no behavioral context: nothing about auth requirements, whether a property_name/site_url is needed, pagination, or how the funnel is computed. It only restates the metric content.

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

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

A single front-loaded fragment naming the metrics, with no filler or repetition. It is efficient, though its brevity for a 17-parameter tool borders on under-specification rather than true 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?

An output schema exists, so return values need not be described. However, for a tool with 17 optional, null-defaulted filters and zero schema documentation, the description leaves the agent unable to know which parameters matter, what defaults apply, or how to scope the query correctly.

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

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

The schema has 17 parameters with 0% description coverage and no enums, and the description explains none of them. Date windowing (days, date_from, date_to, range_preset), scoping (url, site_url, property_name, page_id), and paging (limit, sort_by) are all left completely undefined, so the description fails to compensate for the coverage 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 names a specific data domain (GA4) and concrete metrics: add-to-cart, checkout, purchase funnel stages, and item revenue. An agent can tell this is a funnel/revenue analytics tool, though it does nothing to distinguish itself from siblings like analytics_get_ga4_metrics or analytics_get_organic_roi.

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?

There is no guidance on when to use this versus analytics_get_ga4_metrics, analytics_get_organic_roi, or the platform-specific summary tools. No prerequisites, no exclusions, no mention of required GA4 property context. The agent must infer usage purely from the metric names.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered. The description adds nothing further: no note on auth/account binding, rate limits, whether missing parameters default to a date range, or what 'this account' resolves to.

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

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

A single short sentence that is front-loaded and wastes no words, but its brevity comes at the cost of under-specification rather than genuine efficiency.

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 output schema exists, so return values need not be explained, and annotations cover safety. But with 17 optional parameters, no required fields, and no parameter or usage guidance, the definition leaves an agent without enough information to invoke it correctly.

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

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

Seventeen parameters with 0% schema description coverage and zero explanation in the description. The overlapping filter names (url vs site_url, days vs date_from/date_to vs range_preset, page_id vs property_name) are left entirely ambiguous, which is a severe gap for a tool with this many inputs.

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

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

The description names the domain (GA4 traffic and conversions) and scopes it to 'this account', so an agent knows it retrieves GA4 reporting data. However, it does not distinguish this tool from siblings like analytics_get_ai_referrals or analytics_get_checkout_funnel, nor does it say what metric granularity or breakdowns are returned.

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?

There is no when-to-use guidance, no exclusions, and no mention of the neighboring analytics_* tools that overlap in GA4 reporting. 'For this account' is a scope hint at best, not usage direction.

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 openWorldHint=false, so safety is covered. The description only restates the join scope and says nothing about default date ranges, behavior when a site/property is omitted, or how the sources are matched, so it adds little behavioral context beyond what annotations provide.

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 single sentence is front-loaded and contains no filler, but for a tool with 17 optional parameters it is under-specified rather than genuinely concise. It earns its words but stops well short of what the tool needs.

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?

An output schema exists so return values need not be explained, but a join tool with 17 parameters, zero required and 0% coverage leaves key usage questions unaddressed (how to scope by site/property, which date parameters govern the window). The description is not complete enough for confident invocation.

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

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

Schema description coverage is 0% across 17 parameters, yet the description explains none of them (url, site_url, date_from/date_to, range_preset, activity_only, etc.). With the schema doing nothing and the description offering no parameter meaning, an agent cannot determine how to filter or scope the query.

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

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

The description names a specific operation ('Join') and the two data sources involved (Search Console landing pages and GA4 sessions/conversions/revenue), so the agent can tell it computes an organic-ROI metric. It does not differentiate the tool from siblings like search_get_paid_organic or analytics_get_ga4_metrics, which keeps it from a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternative tools. The agent is left to infer that this is the ROI-focused join rather than the raw metrics tools despite several overlapping 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 declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that: it names the external systems written to (Google, Meta), the required confirm flag, and the permission requirement for the acting user.

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

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

Two tight sentences with the action and its constraints front-loaded and no filler. However, given 33 optional parameters it is arguably under-specified rather than optimally sized.

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 destructive, open-world tool with 33 parameters and zero schema descriptions, the description does not show how to identify which proposal is being executed or what dry_run does. The presence of an output schema covers return values, but the input-side guidance is far from sufficient.

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

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

33 parameters, none required, and 0% schema description coverage, yet the description only clarifies one (confirm=true). It leaves the identity/selection parameters (action_id, name, scope, platform, client_id, rule_id) and the dry_run flag entirely unexplained, which is a substantial 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?

States a specific verb (execute) and resource (a pending pause or budget proposal), and names the two downstream platforms it writes to. It clearly pairs with the sibling propose_* tools, though it never names them explicitly.

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?

"Pending ... proposal" plus "Requires confirm=true and a user who can mutate data" communicates the precondition and the gate for calling it. There is no explicit when-not guidance or named alternative, but the context is clear enough to act on.

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 destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the blast radius is known. The description adds the 'Admin only' auth requirement, which is real added context, but says nothing about the confirm/confirm_live/dry_run safety flags that are present in the schema.

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

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

Two front-loaded sentences with zero filler. Brevity is a virtue here, though the extreme terseness is arguably under-specification rather than economy given the tool's complexity.

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

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

For a destructive tool with 33 undocumented parameters, the definition provides only an auth note. The output schema may cover returns, but the input surface — which fields identify the rule and which are safety switches — is completely unaddressed.

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?

33 parameters at 0% schema description coverage, and the description mentions none of them. An agent has no way to know whether rule_id, name, or scope identifies the target rule, nor what confirm, dry_run, or confirm_live do. The description fails the compensation burden entirely.

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

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

States a specific verb+resource ('Delete an ads alert rule'), which separates it from deletion siblings covering SEO alert rules and automation rules. It stops short of naming those siblings, but the resource is unambiguous.

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

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

'Admin only' is a permission gate, not usage guidance. The description never says when to delete versus upsert (automate_upsert_alert_rule) or how it relates to list_alert_rules, nor does it warn that this is irreversible.

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

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

Annotations already cover the destructive/idempotent/read-only profile, and the description adds the useful 'Admin only' auth constraint. But for a destructive operation whose schema exposes confirm, confirm_live, and dry_run, the description says nothing about dry-run previewing, confirmation requirements, or irreversibility of the deletion.

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

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

Two short sentences, front-loaded with the action, with no filler. It is terse to the point of under-specification, but no sentence is wasted.

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 33-parameter destructive tool with zero required fields and no schema documentation, the description leaves out the identifying parameter, the meaning of confirm/dry_run, and the target rule type. An output schema exists so return values need not be explained, but the invocation-relevant gaps are severe.

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 33 parameters with 0% description coverage and no enums, and the description mentions none of them. An agent cannot tell from the description that rule_id is the likely identifier or what confirm/dry_run do, so the description fails to compensate for the coverage 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?

States a specific verb (Delete) and resource (automation rule), which separates it from the upsert/list siblings. However, it does not differentiate itself from the adjacent delete siblings (delete_alert_rule, delete_seo_alert_rule) or explain what an 'automation rule' is, leaving the title to carry that specificity.

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?

'Admin only' is the sole usage constraint and functions as a permission prerequisite rather than a when-to-use guide. Nothing says when to delete versus deactivate a rule, nor when to prefer the sibling delete tools, and no alternatives are named.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds one genuinely new behavioral fact, the Admin plan and Starter+ tier requirement, which the annotations do not carry, but it omits the likely confirmation/dry-run flow suggested by the confirm, confirm_live and dry_run parameters.

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

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

Two short, front-loaded sentences with no filler. It is efficient, but the brevity is partly under-specification rather than disciplined concision given the complexity of the operation.

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 destructive tool with 33 undocumented, non-required parameters and 0% schema coverage, the description supplies only a purpose and a plan gate. It says nothing about identifying the target rule, the confirmation mechanics, or the intended invocation path, leaving the agent without what it needs to call this safely.

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% across 33 parameters and the description offers no parameter meaning at all. An agent gets no help identifying which field (e.g., rule_id, name, or scope) actually targets the rule, and no guidance on the many null-defaulted fields, so the description fails to compensate for the coverage 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?

States a specific verb ('Delete') and a specific resource ('SEO/AEO alert rule'), which lets an agent distinguish it from automate_delete_alert_rule and automate_delete_automation_rule by resource type. However, it never clarifies what distinguishes an SEO/AEO alert rule from a plain alert rule, so the differentiation still leans on the tool name.

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?

'Admin + Starter+' is a plan/permission gate, not usage guidance. The description never says when this tool should be chosen over the sibling delete tools, nor does it mention the confirm/dry_run path that a 33-parameter destructive operation clearly implies.

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=false, destructiveHint=false, idempotentHint=false, so safety profile is covered. The description adds the useful behavioral fact that this dismisses rather than pausing. But with 33 parameters and no explanation of how any are used (which identify the proposal to dismiss), it leaves significant behavioral context unstated.

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

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

A single economical sentence with no wasted words, front-loading the action and the key modifier ('without pausing'). Its brevity is appropriate, though it leaves a lot unsaid for a 33-parameter tool.

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

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

An output schema exists, so return semantics needn't be described. But for a tool with 33 optional parameters and 0% schema description coverage, the one-sentence description is far too thin to guide correct invocation — it doesn't identify which parameters select the proposal, what confirm/dry_run do, or required identifiers.

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% for 33 parameters with no enums, defaults only. The description mentions none of them, so an agent has no way to know which of the 33 fields actually identify the proposal to dismiss or what 'confirm', 'dry_run', etc. do. This is a severe gap that the description fails to compensate for.

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

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

States a specific verb (dismiss) and resource (a pending pause proposal), and the phrase 'without pausing' distinguishes it from the sibling automate_propose_pause. It's clear, though it doesn't name the sibling alternatives (automate_confirm_action) explicitly.

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

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

The phrase 'pending pause proposal' implies usage context, and 'without pausing' hints at contrast with confirm. However, it never states when to use this vs automate_confirm_action or automate_propose_pause, nor what preconditions (e.g., a proposal must exist) apply.

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 openWorldHint=false, so safety is covered. The description adds useful context beyond that: the data source (synced DB) and the output format (JSON, not PDF, referencing the underlying service/endpoint). It does not mention pagination, size, or auth, but with annotations carrying the safety profile a 3 is appropriate.

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

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

Two short, front-loaded sentences with no filler. The scope qualifier ("no PDF") and data source come early. It is tight, though it leaves obvious capacity unused given the tool's huge surface.

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?

An output schema exists, so return values need not be described. However, for a tool with 33 undocumented, all-optional parameters, the description is far too thin to make the tool callable with confidence. It does not compensate for the total absence of parameter documentation.

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 33 parameters at 0% schema description coverage, and the description explains none of them. The parameter set even contains mutation-flavored fields (confirm, dry_run, confirm_live, action, reason) that are completely unaddressed, leaving the agent unable to know what any argument means.

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

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

The description states a specific verb+resource ("Build a Kampalo performance report JSON") and adds scope detail ("from synced DB (no PDF)"). An agent knows this returns JSON rather than a PDF and pulls from synced data. However, it does not distinguish itself from the many other automate_* and analytics_* siblings.

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

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

There is no when-to-use guidance, no prerequisites, and no named alternative. The "no PDF" note hints at scope but does not tell the agent when to choose this over analytics_get_* or other report tools. Usage must be fully inferred.

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 openWorldHint=false, so safety is covered without the description. The description adds only 'recent' and 'active client' scoping, leaving undefined what 'recent' means, whether results are paginated, and why write-flavored parameters (confirm, dry_run, confirm_live) appear in a read-only list call.

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

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

A single tight sentence with the resource front-loaded and no filler. It is efficient, though arguably under-specified rather than genuinely concise for a 33-parameter tool.

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

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

An output schema exists so return values need not be described, but for a 33-parameter tool with zero required fields and zero schema coverage the description is far too thin. It leaves the agent unable to determine which of the many filters (date ranges, rule_id, action_id, thresholds, etc.) actually apply.

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 33 parameters with 0% description coverage and no enums, and the description mentions none of them. It gives no indication which parameters are meaningful for listing versus the shared/irrelevant blob, so the agent has no basis for filtering correctly.

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

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

States a specific verb (List) and resource (pause proposals and executions) scoped to the active client, so the agent can distinguish it from sibling list tools like automate_list_automation_rules. Minor inconsistency: the title promises 'pause and budget proposals' while the description only mentions pause proposals and executions.

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 on when to use this versus the many sibling listing tools (automate_list_automation_rules, automate_list_alert_rules, automate_list_seo_alert_rules), and no prerequisites or exclusions. 'For the active client' implies context but does not say how the client is determined or when the tool is appropriate.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered by structured data. The description adds nothing beyond that — it does not explain filtering behavior, pagination, or why a read-only listing tool exposes write-flavored parameters such as confirm, confirm_live, dry_run and action_id.

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

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

A single front-loaded sentence with zero wasted words. It is tight and readable, though its brevity borders on under-specification for a tool with this many parameters.

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?

An output schema exists, so return values need not be described. However, with 33 undocumented parameters, no usage guidance, and no filter semantics, the description falls well short of what an agent needs to invoke this tool correctly in the presence of several similarly named listing siblings.

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% across 33 parameters, so the description carries the full explanatory burden. The parenthetical '(ROAS/CPA/spend pace)' vaguely gestures at metric-related fields but gives no meaning to name, scope, threshold, operator, condition, lookback_days, or the confirm/dry_run pair.

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

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

States a specific verb ('List') and resource ('ads performance alert rules') and hints at the metric domain (ROAS/CPA/spend pace). The word 'ads' partially distinguishes it from the sibling automate_list_seo_alert_rules and automate_list_automation_rules, though the separation is by inference rather than explicit contrast.

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?

There is no when-to-use guidance, no prerequisites, and no mention of the other listing tools (automate_list_automation_rules, automate_list_seo_alert_rules) that an agent must choose between. The agent is left to infer selection entirely from the tool name.

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 openWorldHint=false, so the safety profile is covered. The description adds no further behavioral context - nothing about pagination, filter behavior, defaults, or that the 33 parameters are all optional filters, leaving the description essentially empty of value beyond the annotation.

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

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

It is a single short, front-loaded sentence with no wasted words, but it is under-specified rather than genuinely concise, and the 'N-days' shorthand is cryptic rather than clarifying.

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?

An output schema exists, so return values need not be explained, but for a read-only list tool with 33 undocumented optional filters and no usage guidance, the description is far too thin to let an agent call it correctly.

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

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

The tool exposes 33 parameters at 0% schema description coverage, and the description says nothing about any of them. Only a loose hint ('ROAS-below-N-days' gesturing at roas_threshold/consecutive_days) exists, which does not compensate for the near-total absence of parameter meaning.

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

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

The description states a specific verb (List) and resource (automation rules) qualified by 'ROAS-below-N-days pause', which distinguishes it from siblings like automate_list_alert_rules and automate_list_seo_alert_rules. It does not, however, explicitly contrast itself with those list siblings, so it falls just short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as automate_list_actions or the SEO/alert list siblings, and no prerequisites or exclusions are stated. The agent must infer usage entirely from the name and title.

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 openWorldHint=false, so the safety profile is covered. The description adds the plan gate (Starter+), which is useful context, but says nothing about result volume, ordering, or pagination behavior for what could be a long list of rules.

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

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

Two short sentences with the scope stated first and the plan constraint second; nothing is wasted. It is arguably too terse, but that is a completeness problem rather than a structural one.

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 output schema relieves the need to describe return values, but for a 33-parameter tool with zero schema descriptions the description leaves the agent with no idea which filters are meaningful or which are inert for SEO rules. It does not do enough to make the tool callable with confidence.

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% across 33 parameters, and the description names none of them. Names like 'from_amount'/'to_amount', 'min_spend', 'cooldown_hours', and 'report_type' are not self-explanatory in an SEO alert-rule context, so the description entirely fails to compensate for the coverage 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?

States a specific verb (List) and a scoped resource (Search Console / AI-referral alert rules), which distinguishes it from the broader sibling automate_list_alert_rules and automate_list_automation_rules. It does not explicitly name those siblings, but the qualifier 'Search Console / AI-referral' is enough for an agent to route by domain.

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 'Starter+ plan' note gives a real prerequisite that tells the agent when the tool is unavailable, but there is no statement of when to prefer this over automate_list_alert_rules or the upsert/delete SEO siblings. Usage is implied by the domain qualifier rather than stated.

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

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

Adds real behavior beyond annotations: the 20% cap on the daily budget and the deferred-mutation semantics (nothing changes until confirm=true). Annotations already flag readOnly=false/destructive=false, but the cap and staging behavior are meaningful extras not derivable from 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?

Four tight sentences, front-loaded with the action, then param sourcing, then the cap, then the confirmation gate. Every sentence adds a distinct constraint with no filler.

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

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

For a 33-parameter tool with zero schema descriptions, the description covers only the core happy-path params and ignores the bulk of the schema. Output schema exists so return values need no explanation, but the parameter ambiguity is a major gap that the description does not close.

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% across 33 parameters, so the description carries the full burden, yet it only names campaign_id and 'the account id'. The many other params (action, metric, threshold, rule_id, dry_run, etc.) are left entirely undefined, leaving an agent unable to tell which matter for a budget change.

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

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

States a specific verb and resource: 'Create a pending daily-budget change for a selected Google/Meta campaign.' The 'budget' resource naturally separates it from the sibling automate_propose_pause, though it never names that sibling explicitly.

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?

Gives clear context: source campaign_id and the account id from the *_get_campaigns rows, and routes the follow-up step to automate_confirm_action with confirm=true. No explicit when-not-to-use or exclusion, but the workflow positioning 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?

The description discloses that this creates a PENDING proposal and that it does NOT pause until automate_confirm_action – a crucial behavioral fact that separates proposal from execution. It also indicates the two-step workflow, implying the action is reversible/incomplete until confirmed. However, it does not mention idempotency, error behavior, or what happens if dry_run/confirm flags are set, which is relevant for a mutation tool with idempotentHint=false and destructiveHint=false.

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

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

Three sentences, front-loaded with the core action and the critical 'does not pause until' constraint. Efficient and focused, though it could be tightened slightly and the parameter sourcing feels a bit list-like. No wasted words, but not maximally tight either.

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

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

For a mutation tool with 33 parameters, 0% schema description coverage, and a complex two-step workflow, the description gives only the bare essentials (what it does and the follow-up tool). It omits guidance on the many parameters, error handling, idempotency, and interaction with automate_confirm_action beyond the name. An output schema exists, so return values need not be explained, but the parameter and behavior gap is severe.

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% for 33 parameters, so the description must carry the full burden. It only explains how to obtain campaign_id plus either google_customer_id or meta_ad_account_id. The other 30 parameters (dry_run, confirm, confirm_live, threshold, conditions, rules, dates, etc.) are completely undocumented in both schema and description, leaving an agent to guess their meaning and required vs optional nature (required is 0, so all 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 opens with a specific verb+resource: 'Create a pending pause proposal for a selected Google/Meta campaign.' This distinguishes it from the sibling automate_propose_budget (budget proposal vs pause) and from automate_confirm_action (which executes). An agent can identify this as the proposal step of the pause workflow without opening the schema.

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

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

The description provides explicit workflow instructions: it tells the agent where to source campaign_id and customer_id (from google_ads_get_campaigns / meta_ads_get_campaigns) and explicitly names the follow-up tool automate_confirm_action as the step that actually pauses. This is clear when-to-use and what-comes-next guidance, though it does not state when NOT to use this tool (e.g., when a proposal already exists).

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=false, destructiveHint=true and idempotentHint=false. The description adds real value with the auth requirement ('Admin only') and the effect ('Notify after hourly sync; does not pause'), but for a destructive 33-parameter mutation this is thin, and 'does not pause' sits in some tension with the declared destructive/idempotent hints.

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

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

Three short sentences, action stated first followed by constraints. Every sentence adds something (operation, auth, effect) with no filler, though the brevity is very aggressive for a 33-param tool.

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

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

This is a high-complexity tool (33 params, 0% schema coverage). The description does not document parameter roles or the create-vs-update distinction (rule_id, action, condition, etc.), leaving the agent without enough to build a correct call. The output schema does cover return values, so that is not a gap.

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

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

Schema description coverage is 0% across 33 parameters, so the description must carry the burden. It provides no parameter names or meaning at all — only the tangential 'notify/does not pause' behavioral hints — so it fails to compensate for the coverage 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 states a specific verb and resource ('Create or update an ads alert rule'), and the 'ads' qualifier distinguishes it from the sibling seo/automation upsert tools. It does not, however, explicitly name or route away from those alternatives.

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

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

'Admin only' communicates a permission prerequisite, which is useful context. But there is no guidance on when to use this versus automate_upsert_automation_rule or automate_upsert_seo_alert_rule, so usage is only implied.

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 destructiveHint=true and idempotentHint=false, and the description adds real safety workflow detail beyond that: the dry-run default, the inactive default state, and the confirm_live gate for live enablement. It still omits permissions/auth requirements and what happens to unspecified fields on update, which matters for a destructive mutation.

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 with zero filler, and the most safety-critical information (dry_run default, confirm_live requirement) is front-loaded where an agent will read it first.

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?

An output schema exists, so return values need not be described, but a 33-parameter destructive upsert with zero schema descriptions is not adequately covered by three sentences. An agent cannot determine required inputs, update-vs-create semantics, or what most fields mean.

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% across 33 parameters, and the description explains only three of them (dry_run, is_active, confirm_live). Critical fields such as rule_id, scope, condition, operator, roas_threshold, consecutive_days, cooldown_hours, and lookback_days carry no meaning anywhere in the definition.

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

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

The description names a specific verb pair ('Create or update') and a specific resource ('a deterministic ROAS pause rule'), which separates it from siblings like automate_upsert_alert_rule and automate_upsert_seo_alert_rule by rule domain. It stops short of naming those siblings explicitly, so differentiation is inferable rather than stated.

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

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

It gives actionable gating guidance: dry_run defaults to true, is_active defaults to false, and going live requires confirm_live=true. However, it never says when to use this tool versus alternatives such as automate_propose_pause or automate_propose_budget, nor what the upsert key is when updating an existing rule.

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?

Adds genuine context beyond the annotations: the auth/plan requirement ("Admin + Starter+") and the key behavioral fact that this rule type only notifies and "never pauses ads." That reassures the agent the rule's runtime effect is non-mutating even though destructiveHint=true applies to the upsert itself. It still says nothing about dry_run/confirm/confirm_live, which matter for a destructive tool, so it stops short of 5.

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

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

Three tight fragments with zero wasted words, and the purpose is front-loaded ahead of the constraints. The terseness is efficient but arguably too spare for a 33-parameter destructive upsert, so it is not quite ideal sizing.

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?

An output schema exists, so return values need not be described, but the description is far too thin for a tool of this complexity: 33 undocumented parameters, a destructive upsert with dry_run/confirm flags left unexplained, and no create-vs-update routing. An agent could not reliably invoke this from the description alone.

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

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

The schema has 33 parameters with 0% description coverage and no enums, and the description explains none of them. Critical semantics are left entirely undocumented: rule_id vs create, operator/condition/metric, dry_run, confirm, confirm_live, is_active, and the many platform-specific IDs. With zero compensation for a 33-param schema, this is the definition's worst 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?

States a specific verb pair (create or update) and resource (SEO/AEO alert rule), and the name distinguishes it from the sibling automate_upsert_alert_rule and automate_upsert_automation_rule by the SEO/AEO qualifier. However, the description itself never explicitly contrasts this tool with those closely-named siblings, leaving differentiation to inference.

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?

Gives a real precondition ("Admin + Starter+") that tells the agent who may call it and on which plan, which is more than most. But it offers no when-to-use vs alternatives guidance: nothing on upsert vs automate_delete_seo_alert_rule, vs the non-SEO upsert, or when rule_id should be present for update vs omitted for create.

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 openWorldHint=false, so the safety profile is covered. The description adds nothing further — no pagination behavior, no default window, no note on how the 17 optional filters interact.

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

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

A single front-loaded sentence with no filler, but it is under-specified rather than efficiently concise — brevity here reflects missing content, not tight writing.

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?

An output schema exists, so return values need not be described. However, for a tool with 17 undocumented optional parameters and no usage context, the description is far too thin to let an agent invoke it confidently.

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?

17 parameters with 0% schema description coverage and not a single parameter referenced in the description. Names like 'range_preset', 'activity_only', 'user_id', and 'client_id' are left completely opaque; the description does not compensate for the coverage gap at all.

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

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

States a clear verb ('get') plus resource ('Google Ads per-campaign metrics') scoped to 'this account'. The 'per-campaign' framing loosely separates it from account-level siblings like google_ads_get_summary, though it never names those alternatives explicitly.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as google_ads_get_summary, google_ads_get_trends, or meta_ads_get_campaigns. The agent must infer the scenario entirely from the name.

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 cover the safety profile (readOnlyHint=true, openWorldHint=false), so the agent knows this is a safe read. The description adds the comparison baseline ('prior equal window'), which is a useful behavioral detail about how decay is computed. But it doesn't touch on permissions, cost/auth context, pagination, or output structure. With annotations carrying safety, 3 is fair – some added value, notable gaps.

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

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

One dense, front-loaded sentence with no waste. It states the resource and comparison basis efficiently. Too terse for the tool's complexity, but as raw conciseness it's strong.

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 17-parameter tool with 0% schema coverage and no parameter disambiguation, the description is drastically under-specified. The output schema exists so return values needn't be explained, and annotations cover safety, but parameter handling is a major gap. The comparison-window detail is the only substantive content; everything else an agent needs to invoke correctly is missing.

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

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

17 parameters with 0% schema description coverage, and the description provides zero parameter meaning. No mention of url, days, date_from/date_to, range_preset, campaign_name, ad_account, user_id, page_id, etc. Many params appear overlapping (url/site_url, date range fields), which is exactly the situation where description must disambiguate – and it does nothing. Critical failure.

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

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

States a specific resource (Google Ads campaign fatigue) and metric (CTR/CPA/ROAS decay vs prior equal window), so the agent knows what the tool returns. However, it doesn't distinguish itself from sibling fatigue tools like meta_ads_get_fatigue or meta_insights_get_fatigue beyond the 'Google Ads' prefix, and the title already conveys that. Purpose is clear but differentiation from siblings is weak.

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 when-to-use guidance, no alternatives named, no conditions. The comparison window is implied but the agent isn't told when to choose this vs google_ads_get_trends or the meta fatigue siblings. Just a purpose statement, no usage framing.

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?

readOnlyHint=true already tells the agent this is a safe read and openWorldHint=false that it is closed-world. The description only adds that results are 'rolled-up totals' and account-scoped. It says nothing about how date ranges are handled, what dimensions are aggregated, or what happens when 17 optional filters are omitted.

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

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

A single front-loaded sentence with no filler. It is efficient, though this is more under-specification than deliberate 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?

An output schema exists so return values need not be explained, but 17 optional input parameters with zero documentation and no date-range or aggregation guidance make the definition inadequate for correct invocation. One sentence cannot carry this much schema complexity.

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

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

All 17 parameters have 0% schema description coverage and the description adds no parameter meaning whatsoever. Fields like url, days, date_from/date_to, range_preset, page_id, ad_account, and campaign_name are entirely undocumented, leaving the agent to guess at formats and interactions.

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

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

States a specific resource (Google Ads) and nature of output (rolled-up totals) scoped to 'this account'. It implicitly distinguishes itself from google_ads_get_campaigns (per-campaign) and google_ads_get_trends (time series), but never names those siblings or states the distinction explicitly.

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 when-to-use guidance, no mention of alternatives, no prerequisites or exclusions. The only usage context is the implicit 'for this account' scope. An agent gets no help deciding between this and google_ads_get_campaigns or meta_ads_get_summary.

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 openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: no granularity, default date behavior, or note on which of the 17 filters actually affect the trend series.

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

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

A single front-loaded sentence with no filler, which is structurally fine. But brevity here reflects under-specification rather than disciplined conciseness for a 17-parameter tool.

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

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

An output schema exists, so return values need not be explained, but the input side is a black box: 17 optional parameters with no documentation anywhere. For a tool of this complexity the description is far too thin.

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

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

All 17 parameters have 0% schema description coverage and the description mentions none of them. Terms like date_from/date_to, range_preset, days, sort_by, limit, and campaign_name are left entirely unexplained, so the agent must guess at their meaning and interaction.

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

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

States a specific resource (Google Ads spend/clicks/conversion trends) and scope ('this account'), which is enough to distinguish it from a summary or campaign-list tool. However it never explicitly contrasts itself with close siblings like google_ads_get_summary or google_ads_get_fatigue, leaving the agent to infer the difference.

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

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

No guidance on when to choose trends over google_ads_get_summary, google_ads_get_campaigns, or google_ads_get_fatigue, and no mention of prerequisites or typical scenarios. The agent gets a topic but no routing logic.

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 openWorldHint=false, so the safety profile is covered. The description adds nothing beyond that: no pagination/limit behavior, no date-range defaults, no note that all 17 parameters are optional, and no indication of what 'this account' resolves to.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficiently written, though the brevity here reflects under-specification rather than disciplined concision.

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 output schema exists so return values need not be explained, but for a 17-parameter, zero-required tool the description is far too thin. No filtering semantics, no date/pagination behavior, and no routing guidance are provided, leaving the agent under-equipped to call it correctly.

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

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

Schema description coverage is 0% across 17 parameters, so the description carries the full burden and fails it. Terms like days, date_from/date_to, limit, sort_by, activity_only, campaign_name, ad_account and range_preset appear nowhere in the description, leaving their meaning and interactions entirely opaque.

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

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

The description names a specific resource and granularity: per-campaign metrics for Meta Ads on the current account. That distinguishes it from account-level siblings like meta_ads_get_summary and from meta_ads_get_fatigue, though it never explicitly contrasts them. It is clear but minimally elaborated.

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?

There is no when-to-use guidance and no mention of alternatives, despite several close siblings (meta_ads_get_summary, meta_ads_get_fatigue, google_ads_get_campaigns). An agent must infer from the name alone which of these to call for campaign-level data.

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 openWorldHint=false, so the safety profile is covered. The description adds one meaningful behavioral detail — the metric is computed as a relative comparison against the prior window — but says nothing about ranking, thresholds, or how many rows come back.

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

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

A single tight sentence that leads with the resource and enumerates the contributing signals; nothing is wasted. It is perhaps slightly too compressed given the surface area the tool actually exposes.

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?

An output schema exists so return values need not be explained, but a 17-parameter, zero-required tool with no parameter documentation and no usage framing leaves substantial gaps. The description is not sufficient to invoke this tool confidently.

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% across 17 parameters, so the description carries the full burden and fails it. An agent cannot tell what distinguishes url from site_url, ad_account from client_id, or range_preset from date_from/date_to, nor how sort_by and activity_only shape results.

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

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

States a specific analytical concept (ad/creative fatigue) and pins it to concrete signals: frequency plus CTR/CPA/ROAS decay versus a prior window. This is far more than a restatement of the name and lets an agent recognise it as a diagnostic metric tool, though it never explicitly separates itself from close siblings like meta_insights_get_fatigue or google_ads_get_fatigue.

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 when-to-use guidance, no prerequisites, and no routing to alternatives. With three near-identical 'fatigue' siblings in the list, this is a real omission — the agent gets no signal for choosing meta_ads_get_fatigue over meta_insights_get_fatigue.

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 openWorldHint=false, so the safety profile is covered. The description adds only the vague 'for this account' scoping hint and says nothing about pagination, aggregation window, or how the many filter parameters interact with the returned totals.

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 single sentence is front-loaded and free of filler, so it is not bloated. But brevity here comes at the cost of substance, given the tool exposes 17 optional parameters that go unmentioned.

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?

An output schema exists, so return values need not be described. For a read-only summary tool with 17 undocumented filter parameters and no usage guidance, however, the description leaves far too much for the agent to infer before it can call the tool correctly.

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

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

There are 17 parameters with 0% schema description coverage, and the description documents none of them. Nothing explains how url, site_url, ad_account, page_id, ig_user_id, range_preset, days, or date_from/date_to relate to one another, leaving every filter's meaning and precedence opaque.

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

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

The description names the resource (Meta Ads) and the shape of the output ('rolled-up totals for this account'), which is more specific than a restatement of the title. However, it gives no signal distinguishing it from close siblings such as meta_ads_get_campaigns or google_ads_get_summary, so an agent must guess which aggregate tool to pick.

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?

There is no when-to-use guidance, no mention of alternatives, and no preconditions. With siblings like meta_ads_get_campaigns and meta_ads_get_fatigue in the same namespace, the agent gets no routing help at all.

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 openWorldHint=false, so the safety profile is covered. The description adds only the 'for this account' scope and nothing about what the comparison returns, how platforms are aligned, or any data-freshness caveats, so it contributes almost no 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 single sentence is front-loaded and free of filler, so it is structurally clean. But for a 17-parameter comparison tool it is drastically underspecified, which is a sizing problem rather than genuine 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?

An output schema exists, so return values needn't be spelled out, but the description still omits how the two platforms are parameterized, which identifiers are required, and how the date window is chosen. For a tool this complex with zero parameter documentation, the definition is far from 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 17 parameters and 0% schema description coverage, the description carries the full burden of explaining the inputs and explains none of them. It is impossible to tell from the definition how date_from/date_to, range_preset, days, sort_by, or the many account-identifier parameters (ad_account, page_id, ig_user_id, client_id, site_url) shape the comparison.

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

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

The description says what the tool does at a high level — it compares Google vs Meta ads for the current account — so the verb and resource are recoverable. However, it is essentially a restatement of the title 'Compare Google and Meta' and adds no differentiation from the sibling summary tools (google_ads_get_summary, meta_ads_get_summary) that also report 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?

There is no guidance on when to use this comparative tool versus the per-platform summary or trends tools in the sibling list. No prerequisites, exclusions, or alternatives are stated; the agent must infer usage from the name alone.

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