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, openWorldHint=true and non-idempotency; the description adds context annotations can't convey — that it writes out to Google/Meta ad platforms and requires a user with data-mutation rights plus confirm=true. It stops short of stating irreversibility or what gets changed on the external platform, but the added auth/external-write detail is real value beyond the structured 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?

Two short sentences, front-loaded with what runs and where it writes, followed by the gating prerequisite. Nothing 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?

An output schema exists so return values need no explanation, but for a destructive 34-parameter, 0%-documented tool the description is far too thin: it gives no guidance on which parameters select the proposal or which are action-type-specific, leaving an agent likely to mis-populate a live external mutation.

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?

34 parameters at 0% schema description coverage, and the description documents only one (confirm=true). It doesn't explain that action_id/rule_id identify the proposal, which fields are needed for a pause vs. budget action, or what dry_run does — the agent must guess across a very large, undocumented surface.

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: executes a pending pause or budget proposal, and names the two external write targets (Google, Meta). An agent can distinguish it from automate_propose_pause / automate_propose_budget by the 'execute pending' framing, though it doesn't name those siblings 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?

Implies the workflow (run a proposal that already exists) and states a hard prerequisite (confirm=true, mutating user), but never explicitly says to call automate_propose_pause or automate_propose_budget first, nor when to use automate_dismiss_action instead. Usage is inferable but not spelled out.

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 irreversible nature is covered structuredly. The description adds the admin permission requirement, which is genuinely useful extra context, but stays silent on the safety parameters (confirm, confirm_live, dry_run) that govern whether the delete is actually executed.

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 and followed by the permission constraint, so nothing is wasted. But the brevity is under-specification for a 34-parameter destructive tool rather than genuine economy.

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 no explanation, and annotations cover the safety profile. Still, for a destructive tool with 34 undocumented optional parameters, the description omits the essentials an agent needs: how to identify the rule to delete and whether a confirmation flag is required.

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 34 parameters at 0% description coverage and zero required fields, so the description carries the full burden. It names none of them, giving no indication whether rule_id, name, scope, or a combination identifies the target rule, nor that dry_run and confirm exist. An agent cannot map intent to arguments from this text.

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

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

States a specific verb+resource ('Delete an ads alert rule'), which cleanly distinguishes it from automate_upsert_alert_rule and the sibling delete tools for SEO and automation rules. It is not tautological, though it offers no detail beyond the title.

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' gives a real prerequisite for use. However, it says nothing about when to choose this over automate_upsert_alert_rule (e.g., deactivating via is_active) or about discovering rules first with automate_list_alert_rules, leaving the routing to inference.

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

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

The description adds no behavioral context beyond the operation's effect, which is already implied by the verb 'Delete' and confirmed by the annotations ('destructiveHint': true). It fails to clarify potential side effects 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?

The description is extremely concise and efficient, serving only as a minimal identifier, making it appropriate for its brief function.

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

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

Given the extreme complexity of 34 parameters with 0% schema coverage, the description is functionally incomplete. It gives the AI agent no meaningful context to guide its parameter filling or decision-making before execution.

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 34 input parameters and 0% schema description coverage, the description provides no semantic value to the parameters. An agent cannot use this single sentence to understand how or why specific parameters (like 'roas_threshold' or 'lookback_days') are relevant.

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 ('Delete') and the resource ('automation rule'). However, it fails to distinguish this tool from other deletion siblings (like delete_alert_rule), which requires relying heavily on the title.

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 only provides a single operational prerequisite ('Admin only'). It offers no guidance on when to use this tool versus when to use related list or upsert functions, nor does it define any failure conditions.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the core safety profile is known. The description adds plan/admin eligibility, but does not explain irreversibility, what confirm/dry_run do, or what happens if the rule is missing—all important for a destructive tool.

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

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

Two short sentences with no filler and the action front-loaded. It is concise, though its brevity contributes to the missing parameter and behavior detail.

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

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

Given 34 undocumented parameters, no required fields, a destructive operation, and a large optional schema, the description is far too thin. The output schema reduces the need to explain return values, but critical input and safety behavior remain 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?

There are 34 parameters with 0% schema description coverage, and the description names none of them. It does not clarify which parameter identifies the rule (rule_id), what dry_run or confirm do, or why unrelated parameters such as campaign_id or date_from exist on a delete tool.

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

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

States a specific verb (Delete) and resource (SEO/AEO alert rule), clearly distinguishing it from upsert/list siblings by operation. It does not explicitly contrast with automate_delete_alert_rule or automate_delete_automation_rule, but the resource name is specific enough.

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?

Mentions the Admin and Starter+ eligibility prerequisites, which is useful. However, it gives no guidance on when to use it versus listing or upserting rules, nor on whether rule_id must exist or whether dry_run/confirm should be used first.

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 readOnly=false, destructive=false, and idempotent=false. The description adds only that dismissal happens 'without pausing', but does not explain what dismissal removes, whether it is reversible, or how confirm/dry_run parameters affect execution for this 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?

A single front-loaded sentence with no wasted words. It is as concise as possible for what it chooses to say.

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 34-parameter mutation with zero schema descriptions, one sentence is drastically incomplete. Even though an output schema exists, the input surface and confirmation behavior are entirely undocumented.

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 34 parameters with 0% description coverage, and the description provides no parameter-level information. It does not explain key fields like action_id, rule_id, confirm, dry_run, or any of the campaign/metric/account fields.

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 pause-related siblings. It does not explicitly name alternatives such as automate_confirm_action, so it stops short of full sibling differentiation.

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 mention of a 'pending pause proposal' implies the usage context, but there is no explicit guidance on when to use this instead of confirming, proposing, or ignoring a proposal. Alternatives and exclusions are left to inference.

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

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

Annotations already disclose non-read-only, open-world, non-idempotent, non-destructive behavior. The description adds valuable context beyond annotations: default recipient behavior, a confirmation gate for external recipients, and a plan prerequisite.

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 four short sentences with the purpose front-loaded first, followed by key constraints. Every sentence adds a meaningful operational rule without 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?

An output schema exists, so return values need not be described. However, for a 34-parameter tool, the description is far too sparse: it omits report configuration, date range options, dry_run behavior, rule/action fields, and most other invocation details.

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 34 parameters with 0% schema description coverage. The description only clarifies email_to and confirm semantics, leaving the other 32 parameters opaque and forcing the agent to guess their purpose.

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: generate a Kampalo performance report PDF and email it. The emailing step distinguishes it from sibling report-generation tools, so an agent can tell what makes this tool unique.

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 clear usage conditions: default to the signed-in user's email, require confirm=true for other email_to recipients, and require a plan with scheduled reports. It does not explicitly compare with sibling tools, but the operating 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 openWorldHint=false, so the agent knows this is a safe read operation. The description adds that it pulls from a synced DB and returns JSON rather than a PDF, which is useful behavioral context. However, it does not explain the large parameter surface, potential side effects (e.g., confirm/dry_run flags), or what the report contains beyond the output schema. Given the 34 parameters and low schema description coverage, more behavioral detail would be expected.

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 and front-loads the core purpose: building a report JSON. The second sentence adds implementation context without excessive verbosity. It could be slightly more informative about usage, but it is appropriately sized and avoids filler.

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

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

Given the tool has 34 input parameters with no schema descriptions, a concise purpose statement is insufficient. The description does not explain which parameters are relevant for report generation versus automation rules, nor does it provide usage guidance. Although an output schema exists, the input-side context is critically 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 schema has 34 parameters with 0% description coverage, meaning none of the parameters are documented in the schema. The description says nothing about any parameter's meaning, format, or relevance to the report generation. Even with an output schema, the input parameters are completely unexplained, leaving the agent unable to determine how to use most of them.

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

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

The description states a specific verb and resource: 'Build a Kampalo performance report JSON'. It also distinguishes the output format by saying '(no PDF)', which helps differentiate from a PDF-based report tool. However, it does not explicitly differentiate from sibling tools like automate_email_report, which also produces reports, so it falls short of a full 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions an internal endpoint, but that does not help an agent decide between this and other report or automation tools. There is no indication of prerequisites, typical scenarios, or 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?

readOnlyHint=true already tells the agent this is a safe read, so the description adds little beyond the 'active client' scoping and the vague word 'recent'. It says nothing about the default time window, result ordering, pagination, or why a read-only listing would expose confirm/dry_run/confirm_live flags — a genuinely confusing signal an agent needs resolved.

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 clean, front-loaded sentence with no filler, but here the brevity is under-specification rather than efficiency. The size is appropriate; the content is not.

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 34-parameter listing tool with zero schema coverage the description should at minimum explain the filter surface, the meaning of 'recent', and how to relate results to automate_confirm_action / automate_dismiss_action. None of that is present.

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 34 parameters, so the description carries the full burden and mostly fails it. Only 'active client' weakly maps to client_id; date_from/date_to, action, scope, rule_id, and the confirm/dry_run/confirm_live flags are entirely unexplained in both places.

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 gives a specific verb (List) and a specific resource (Kampalo pause proposals and executions) scoped to the active client, which distinguishes it from the mutation siblings automate_propose_pause and automate_confirm_action. It does not, however, differentiate itself from the several automate_list_* siblings, and it drops the 'budget' half of the title, so the inventory of what is listed is slightly inconsistent.

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 only usage cue is 'for the active client', which implies no client selector is needed. There is no statement of when to reach for this vs automate_list_automation_rules or the propose/confirm tools, and no guidance on the many optional filter parameters that clearly exist for narrowing the query.

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

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

The annotations already declare readOnlyHint=true and openWorldHint=false, so safety is covered and the bar is lower. The description adds that these are ads performance rules tied to ROAS/CPA/spend pace, which is useful context beyond the annotations, but it never explains that the 34 parameters act as filters (or that many, like confirm/dry_run/reason, are irrelevant to a read), nor does it mention result volume or ordering.

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 front-loaded sentence with no filler, which is structurally clean. However, the brevity reflects under-specification rather than disciplined concision given the 34-parameter surface the agent must navigate.

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 tool exposing 34 undocumented optional parameters and multiple look-alike siblings, one sentence about the rule family is not enough to tell an agent how to filter or what the results will represent.

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 34 parameters, so the description carries the full burden and largely fails it. The only semantic hint is the parenthetical naming ROAS/CPA/spend pace, which loosely maps to the metric and threshold-type parameters, while rule_id, scope, is_active, platform, campaign_id, and the many mutation-oriented fields (confirm, dry_run, confirm_live) are left entirely unexplained.

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

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

The description gives a specific verb and resource ("List ads performance alert rules") and parenthesizes the rule family it covers (ROAS/CPA/spend pace), which distinguishes it from the sibling upsert/delete variants and from the SEO/automation rule lists. It does not explicitly name those siblings, so differentiation is implied 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?

There is no statement of when to use this tool versus the close siblings (automate_list_automation_rules, automate_list_seo_alert_rules, or the upsert/delete alert-rule tools). The agent must infer from the name alone that this is the read path for ads alert rules, and no filtering or prerequisite guidance 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?

The readOnlyHint annotation already establishes that this is a safe read operation, and the description is consistent with that. However, it adds almost no behavioral context beyond the title: it does not explain filtering behavior, default scope, whether all rule types are returned, or how the many optional parameters affect results.

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, which is good. But for a 34-parameter listing tool, it is under-specified rather than appropriately concise, leaving no structure for the filtering 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, and the annotations cover the read-only profile. Still, given 34 undocumented optional parameters and 0% schema description coverage, the description is too thin to call this tool correctly beyond a no-argument listing.

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 34 optional parameters with 0% description coverage, and the description provides no mapping or meaning for any of them. Even domain terms like ROAS threshold or consecutive days are not explicitly tied to roas_threshold, consecutive_days, or related filters.

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

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

The description uses a specific verb ('List') and resource ('pause automation rules') narrowed by ROAS/days, so an agent can tell this lists a particular rule category. It does not explicitly distinguish itself from sibling list tools such as automate_list_alert_rules or automate_list_seo_alert_rules.

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 the other list-rule siblings, no prerequisites, and no exclusions. The description merely states what it lists, leaving tool selection to inference 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 already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds useful plan-gating context ("Starter+ plan"), but it says nothing about the 34 optional filters or how they affect the listing 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 and front-loaded with the core listing action. The plan note is relevant and earns its place, though the extreme brevity leaves critical parameter context absent.

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

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

Although an output schema exists, this is a 34-parameter filtering tool and the description explains none of the filter dimensions. It gives only purpose and plan eligibility, leaving the agent unable to construct a meaningful filtered query.

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 34 parameters with 0% description coverage, and the description provides no parameter semantics at all. With no compensation from the description, an agent cannot know what name, scope, metric, threshold, date_from, or the other filters mean.

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 — listing Search Console / AI-referral alert rules — which distinguishes it from the generic alert-rule siblings like automate_list_alert_rules. It is clear, though it does not explicitly name the sibling alternatives it replaces.

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 only usage-related information is "Starter+ plan," which is an eligibility constraint rather than guidance on when to choose this tool over automate_list_alert_rules or automate_list_automation_rules. No when-to-use or when-not-to-use conditions are given.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent, so the bar is lower, yet the description adds real context beyond them: the proposal stays pending, it is capped at 20% of current daily budget, and it does not mutate until a separate confirm call. It does not mention the dry_run or confirm parameters even though they exist 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?

Four sentences, no waste, front-loaded with the action, followed by ID sourcing, the 20% constraint, and the confirmation gate. Each sentence adds decision-relevant information.

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

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

An output schema exists so return values need not be explained, and the core propose-then-confirm flow is covered. However, with 34 optional parameters at 0% coverage, an agent is still left guessing which fields (to_amount, platform, dry_run) actually matter for this operation, which is a notable gap for a tool of this complexity.

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

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

Schema description coverage is 0% with 34 parameters, and the description clarifies only campaign_id and the account id (google_customer_id/meta_ad_account_id). The remaining ~30 parameters, including to_amount, dry_run, and confirm, receive no explanation, so the description does not 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 gives a specific verb and resource ('Create a pending daily-budget change') scoped to Google/Meta campaigns, and the word 'propose' cleanly distinguishes it from automate_confirm_action and automate_propose_pause. An agent can identify it without opening the schema.

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

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

It explains the workflow: pull campaign_id and the account id from the *_get_campaigns rows, then confirm later via automate_confirm_action with confirm=true. It stops short of explicitly naming when to prefer automate_propose_pause, but the sequencing and prerequisites are 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 indicate this is not read-only, not destructive, and not idempotent. The description adds important workflow context: this creates only a pending proposal and does not pause the campaign until a later confirmation step.

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

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

The description is three tight sentences, front-loaded with the core action and followed by identifier sourcing and the confirmation constraint. There is no wasted wording.

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

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

Although an output schema and annotations exist, the input surface is large and entirely undocumented in the schema. The description names only a few identifiers and does not explain enough about the many optional parameters or the required setup for this tool to be complete given its 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?

The schema has 34 parameters with 0% description coverage, and the description explains only the key identifier parameters campaign_id, google_customer_id, and meta_ad_account_id. Most parameters, including reason, platform, action, confirm, dry_run, and threshold-related fields, remain undocumented in both the schema and description.

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

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

The description states a specific verb and resource: creating a pending pause proposal for a selected Google/Meta campaign. It also distinguishes this from the sibling tool that actually performs the pause, automate_confirm_action.

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

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

It clearly tells the agent where to obtain the campaign and account identifiers from (google_ads_get_campaigns / meta_ads_get_campaigns) and notes that the pause does not happen until automate_confirm_action. It does not explicitly compare against other proposal tools such as automate_propose_budget, but the usage context is otherwise 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 adds real context beyond annotations: admin-only access, hourly-sync evaluation timing, and that the rule notifies rather than pauses campaigns, which softens the destructiveHint. However, for a destructive 34-parameter mutation it says nothing about confirm/dry_run safety flow, what an update overwrites, or reversibility.

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, front-loaded sentences with zero filler; the operation and its constraints come first. It is efficient, though the space saved is not reinvested in any parameter or safety detail.

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

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

Given a destructive, 34-parameter tool with no parameter documentation, the description is far too thin for correct invocation—an agent cannot know how to use dry_run/confirm or how to target an existing rule. The output schema covers return values, so that gap is acceptable, but the input-side 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?

The schema has 34 parameters with 0% description coverage, and the description explains none of them. Critical fields like rule_id (create vs update), dry_run, confirm, confirm_live, and confirm_live's role in a destructive mutation are left entirely undocumented; only the phrase 'create or update' hints at rule_id semantics.

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

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

States a specific verb (create or update) and resource (ads alert rule), which clearly separates it from the delete/list variants. It does not explicitly distinguish 'ads alert rule' from siblings automate_upsert_automation_rule or automate_upsert_seo_alert_rule, so an agent must infer the boundary.

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' gives a clear permission precondition and 'Notify after hourly sync; does not pause' tells the agent this is notification-only rather than an action-taking tool. It stops short of naming the alternative (e.g. automate_propose_pause) for pausing, so routing is implied rather than explicit.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the safety bar is lower, and the description usefully adds the safe-default posture (dry_run=true, is_active=false) and the confirm_live escalation gate. It does not say what a dry run returns, whether confirm_live overrides dry_run, or what existing state an update overwrites — meaningful gaps for a destructive write.

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 decision-relevant fact (dry_run default) is placed early. The terseness is efficient, though for a 34-parameter tool it edges toward under-specification rather than optimal density.

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 34 parameters, an upsert with two distinct modes, and no parameter documentation, the description is far too thin. An output schema exists so return values need no explanation, but the agent gets no help on required create fields, rule scoping, or the relationship between confirm, confirm_live, and dry_run.

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 34 nullable parameters, so the description must carry the load and it explains only three of them (dry_run, is_active, confirm_live). Nothing is said about the domain-critical fields (roas_threshold, consecutive_days, cooldown_hours, max_actions_per_day, scope/platform) or about which fields are required to create vs update.

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?

Specific verb pair (create or update) plus a concrete resource ('deterministic ROAS pause rule'), which lets an agent tell it apart from the generic alert-rule siblings. It does not explicitly distinguish itself from automate_upsert_alert_rule / automate_upsert_seo_alert_rule, so the differentiation is inferred from the ROAS/pause wording 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?

The description supplies a useful operating procedure (dry-run by default, inactive by default, confirm_live required for live enable), which is real when/how guidance. It never explains when to create versus update (rule_id presence), nor does it point to sibling tools for non-ROAS rules, leaving the core routing decision 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?

Adds genuinely useful context beyond the annotations: 'Notify only; never pauses ads' clarifies the blast radius of a tool flagged destructiveHint=true, and the admin/plan requirement is a real invocation gate. It does not explain the create-vs-update branch or confirm/dry_run behavior, so not a 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?

Two short, front-loaded sentences with no filler and the key safety statement placed early. Efficiency is good, though the extreme terseness is under-specification rather than true concision given the parameter 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?

For a 34-parameter destructive upsert with zero schema descriptions, the definition is far too thin: no create-vs-update semantics, no dry_run/confirm workflow, no indication which fields apply to SEO vs AEO rules. An output schema exists, so return values need not be described, but the input surface is largely unexplained.

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 34 parameters at 0% schema description coverage, the description carries the full burden and contributes nothing — no mention of threshold, operator, metric, rule_id, dry_run, confirm, lookback_days, or cooldown_hours. An agent cannot tell which of the 34 nullable fields are needed for which alert type.

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 pair (create/update) and specific resource (SEO/AEO alert rule), which distinguishes it from the generic automate_upsert_alert_rule and automate_upsert_automation_rule siblings. However it doesn't explicitly name those siblings or the conditions that select one over the other.

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?

Only a prerequisite is given ('Admin + Starter+'); there is no guidance on when to create vs update, how it differs from the three other upsert_* siblings, or what to do when rule_id is omitted. The agent must infer the routing itself.

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

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

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.