AdAce Ads

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

Annotations declare a destructive, non-idempotent, open-world write. The description adds crucial context beyond that: owner/admin authorization, batch limit of 10, policy restrictions, the APPROVAL_TOO_SOON refusal, and that the result repeats what will change. No contradictions with annotations.

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

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

Every sentence earns its place: consent, authorization, batching, error handling, result semantics, and next step. The core action and the explicit-yes requirement are front-loaded, then constraints follow in a logical order.

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, batch-capable, open-world operation with no output schema, the description covers everything an agent needs: consent, authorization, limits, error behavior, and follow-up. Nothing critical 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?

Schema coverage is 67%, with change_id lacking a description. The description compensates by explaining that code is ignored, that change_ids is for batches up to 10, and that only IDs shown to the person should be used. It adds meaningful semantics beyond the schema, though change_id's individual usage is only implied.

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 (approve) and resource (pending change proposals), plus the consequence (queue them for execution). It clearly distinguishes from siblings like propose_change and get_change_status by naming the latter as the follow-up.

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

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

Explicitly says when to call: only after an explicit yes from the person, only with the IDs shown, never on own initiative, and with the 20-second reading window. It also names the alternative for launching campaigns (pass all change_ids from propose_launch) and points to get_change_status afterward.

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 read-only, idempotent, non-destructive, and open-world behavior. The description adds meaningful context beyond that: spend_total_converted uses NBU daily rates and is only an indicative converted total, which affects how the result should be interpreted. It does not discuss permissions or rate limits, so it is 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?

The definition is one compact, front-loaded sentence that states the main result and immediately qualifies the currency conversion as indicative. It contains no redundant restatement of the title or annotations.

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

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

For a read-only overview tool with no output schema, the description explains the main returned totals and the indicative-conversion caveat. However, it omits usage guidance and client_id semantics, leaving gaps for an agent deciding when and how to call it.

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 documents date_from and date_to well, but client_id has no description, and the tool description does not explain it either. The description only mentions spend_total_converted, an output field, so it does not compensate for the remaining parameter-documentation gap at 67% schema coverage.

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

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

The description states a specific resource and result: an overview of a client's accounts with total spend and currency-converted totals. It is clear enough to distinguish the broad purpose, but it never names sibling tools such as list_accounts, list_clients, or get_performance, so the boundary is left implicit.

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 or when-not-to-use guidance, and no alternative tools are named. An agent must infer from the description alone whether this is better than list_accounts, list_clients, or get_performance.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, and openWorld, so the safety profile is covered. The description adds a genuinely useful behavioral note—that results include incomparability warnings—which an agent would not otherwise know. It stops short of describing the response shape, limits, or what triggers the warnings.

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 compact sentence with the core operation front-loaded and no filler. It is efficient, though the terseness contributes to the missing mode and usage detail rather than compensating for it.

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

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

With no output schema, 4 parameters, and the mode enum undescribed, the description should carry more weight than one sentence. It omits how mode interacts with the date defaults and what the incomparability warnings look like, leaving real gaps for an agent configuring a comparison.

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

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

Schema description coverage is 50%, and the one undocumented parameter is the critical one: `mode` has an enum of previous_period/previous_month/previous_year but no description in the schema and no explanation here. The phrase 'the previous one' is ambiguous precisely where mode needs disambiguation; only date_from/date_to are documented, and that documentation lives in the schema, not the description.

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

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

States a specific operation (comparison of a period with the previous one) and names the outputs (absolute/relative change, incomparability warnings). This is distinguishable from sibling analytics tools like get_performance or find_anomalies, though the description never explicitly contrasts with them or clarifies what 'the previous one' means against the three available modes.

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 choose this tool over get_performance, find_anomalies, or find_waste, which all touch related analytics territory. No prerequisites, exclusions, or alternative routing are mentioned.

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 rich annotations: created paused with no spend, enabling as a 'status proposal', server-side image download, and field rechecks before paused creation. It does not fully disclose idempotency/rate behavior, but the paused/no-spend semantics materially enrich what annotations already declare (destructiveHint=true, openWorldHint=true).

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 core purpose is front-loaded, but the body is a single dense wall of text with nested semicolon clauses that is hard to scan. Every clause carries information, but structure (bullets/grouping) is missing, making recall difficult for a 31-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?

For a 31-parameter multi-platform mutation with no output schema, the description is impressively complete on required fields, format-specific requirements, and platform constraints. A few peripheral params (apply_utm, optimize_order) and the return behavior are left unstated, keeping it just short of fully complete.

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

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

Despite only 52% schema description coverage, the description supplies meaning for many parameters — headline/description counts and character limits, card counts, final_url https requirement, image/video/document size limits, and call_to_action value sets. Some fields (link, apply_utm, optimize_order, name) remain implicit, but overall it compensates well 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?

Opens with a specific verb+resource ('Create a paused ad in an ad group') and immediately clarifies the safety-relevant scope ('no spend; enabling is a status proposal'). The rest of the text elaborates distinct per-platform modes, letting an agent distinguish it from create_ad_set and create_campaign without opening schemas.

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

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

Explicitly routes between mode=copy and mode=new, and enumerates which fields/format apply per platform (Google, Meta, Microsoft, LinkedIn) and per format (image, carousel, video, document). It names the sibling that precedes it (create_campaign) and states which campaign formats are eligible for each creative type.

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, openWorldHint=true and non-read-only, so the safety profile is covered. The description adds context beyond that: the ad group is created paused with no spend, no approval flow is triggered, budget fields only apply to campaigns without a budget, and conversion objectives require pixel_id plus an event. It stops short of saying what is returned or what permissions/account scopes are needed.

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 purpose is front-loaded, but the remainder is a single run-on paragraph mixing Meta, Google and Microsoft specifics with no separation, making it hard to scan for the platform in use. The length is defensible for 24 params, but the lack of structure wastes reader effort.

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 24-field, nested-object mutation with no output schema, the description covers the important semantics: defaults, budget constraints, conversion requirements and placement fallbacks. Gaps remain around the returned identifier and whether the parent campaign must be in a particular status, but nothing critical to a correct call 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?

With 24 parameters at 42% schema coverage, the description carries the burden and largely does: it explains cross-field constraints (budget_minor/lifetime_budget_minor only for unbudgeted campaigns, lifetime requires end_time, custom_event_type must match the custom conversion, advantage_audience must be set explicitly, age range 13–65) and the source tools for countries/regions/cities/interests. Several parameters, notably page_id, languages and the placement sub-fields, are only covered by schema 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?

The opening clause states a specific verb and resource ('Create a paused ad group in a campaign') and immediately discloses the default state, which distinguishes it from create_campaign and create_ad. It never names those siblings explicitly, so differentiation is inferred from the resource noun 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?

'no spend, no approval needed; enabling is a status proposal' gives useful context that this tool is safe to call without the propose_change/approve_change flow, which is real guidance. However, it never states prerequisites (existing campaign, matching campaign type) or when to choose this over create_ad or a platform-specific change tool; usage is implied rather than stated.

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

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

Goes well beyond the annotations: creation is paused with 'no spend, no approval needed', Reddit 'requires a pixel for every ad group and reviews the ad (up to 48 business hours)', LinkedIn 'fixes the format at creation' and turns Audience Network off, the daily budget is capped by the client's policy, and budget-sharing is 'true recommended by Meta'. These are exactly the side effects an agent needs on a mutation 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?

Front-loads the core purpose in the first clause, which is good, but the rest is a single monolithic run-on paragraph with no per-platform separation, making it hard to scan. Nearly every sentence carries real constraints, so little is wasted, yet the structure works against easy retrieval.

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 28-param, multi-platform mutation with no output schema, it covers creation prerequisites, targeting sources, and per-platform constraints comprehensively. The notable gap is that it never says what is returned (e.g. campaign ids), which an agent needs since no output schema exists.

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 only 32% schema coverage across 28 params, the description carries the burden and does: character limits (headlines 30, descriptions 90/60, business_name 25), per-format counts (PERFORMANCE_MAX 3–15 headlines, DISPLAY exactly one long_headline, DEMAND_GEN video alternative), image aspect ratios and minimum pixel sizes, and bidding/budget interactions. It adds meaning far beyond the raw schema.

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

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

States a specific verb+resource (create a campaign) plus the crucial state qualifier: paused, no spend, no approval needed. It then enumerates four platform families with different creation semantics, making it unmistakable what the tool does versus siblings like create_ad_set or create_ad.

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 condition-based routing: PERFORMANCE_MAX/DEMAND_GEN/DISPLAY 'are created together with their asset group or ad group and ad', and ChatGPT Ads explicitly says the ad group and ad 'are added with create_ad_set and create_ad'. It also points to sibling lookups (search_linkedin_targeting, search_reddit_targeting, search_openai_locations). It never states a general when-not-to-use, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful behavioral detail that the target can be a dotted catalog operation (google_ads.get_structure) as well as a tool, but says nothing about what the returned schema looks like or whether output is text or structured.

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 the core subject stated first and no filler. It is appropriately sized for a one-parameter introspection tool, though the parenthetical example arrives before the reader knows what a 'catalog operation' means.

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

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

With no output schema, the description should at least characterize the return value; 'the full argument schema' does so loosely. It is not enough for a tool whose only job is introspection and which sits next to a same-purpose sibling — the agent lacks the discriminator it needs.

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

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

Schema coverage is 0% — the required `name` parameter has no description in the schema — so the description must carry the burden. It partially compensates by showing the dotted-operation format 'google_ads.get_structure', which implies accepted values extend beyond plain tool names, but it never states the expected format explicitly for the tool-name case.

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 (the full argument schema) and its scope (a tool or a catalog operation), but it is a noun phrase with no verb and gives no differentiation from the near-identical sibling get_tool_schema or from search_tools. An agent can guess the purpose but cannot tell it apart from siblings on the description alone.

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 call this versus alternatives. With a sibling literally named get_tool_schema, the omission is costly — the agent has no stated basis for choosing one over the other, and no prerequisites or call ordering are mentioned.

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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuine method context not present in structured fields: the 4-week same-weekday median baseline and inclusion of campaign contributions. It stops short of saying what counts as an anomaly (threshold, significance) or how results are ordered, which matters for interpreting the output.

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 short sentence with no wasted words, and the key concept (baseline method) is front-loaded. But the terseness comes at the cost of specification rather than serving conciseness — it is a fragment, not a complete statement of behavior.

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

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

For a read-only analytical tool with no output schema and an incompletely documented parameter set, the description should explain what an anomaly looks like in the response and how campaign contributions are attributed. As written, an agent cannot predict the shape or meaning of the result before calling it.

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

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

Schema coverage is 67%: date_from and date_to are well documented in the schema, but account_id has no description at all. The description contributes nothing about parameters — it does not restate the default 7-day window, the 31-day cap, or the account scoping, so the undocumented parameter is 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 names the resource (anomalies) and gives the detection method (deviation from the median of the same weekdays across 4 weeks, plus campaign contributions), which is more than a restatement of the name. However, it is a noun-phrase fragment with no verb and no statement of what the tool actually returns (a list of flagged days? a ranked table?). It also fails to distinguish it from close siblings like find_waste or compare_periods, which an agent could easily confuse with anomaly detection.

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 call this over alternatives such as compare_periods, get_performance, or find_waste, and no conditions or prerequisites are stated. The statistical method hints at the use case but the agent must infer that anomaly screening is the intent.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so safety is covered. The description adds meaningful value with the caveat that the figures are the spend the signals relate to and not guaranteed savings, preventing output misinterpretation. However it says nothing about the shape of the returned signals or how many are 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?

Two short sentences, front-loaded with the definition, then the interpretation caveat. Every sentence earns its place; minor vagueness from 'over final days' when explicit date parameters exist.

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?

A five-parameter detection tool with no output schema and 40% parameter coverage leaves the two threshold parameters (min_spend, min_clicks) unexplained anywhere, and gives no clue about the structure or volume of returned signals. More was needed given how little structured data exists.

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

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

Schema coverage is only 40%, so the description needs to compensate and does not: date_from/date_to are documented in schema, but min_spend and min_clicks have no schema descriptions and the description never mentions them or the fact that min_spend is a string. Only the vague phrase 'over final days' hints at the date window.

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 detection concept with concrete criteria: campaigns with spend and clicks but no conversions over the final days. An agent can tell this apart conceptually from get_performance or tracking_audit, though the description never names an alternative sibling to distinguish itself from them.

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

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

No explicit when-to-use or when-not-to-use guidance, and no alternatives suggested despite relevant siblings like find_anomalies, compare_periods, and tracking_audit. The rationale is implied by the purpose only.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds scope information (GA4-side attribution gap, untagged traffic) but says nothing about auth requirements, rate limits, data freshness, or why property_id would need to be supplied. Adequate but shallow beyond annotations.

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

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

Front-loaded with 'GA4:' and dense with useful metric names, but delivered as one semicolon-and-em-dash chain that reads as a spec dump. Every clause carries information, yet the lack of sentence structure makes it harder to scan than it needs to be.

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

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

With no output schema, the description does the necessary work of enumerating returned content (sessions, key events, revenue, CPA/ROAS, attribution gap, uncampaigned traffic) and states the one required parameter's role. Remaining gap is row granularity/by-dimension breakdown and date-range limits, which the schema partially covers.

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

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

Schema coverage is 50%: date_from/date_to are well documented incl. defaults, while client_id and property_id have no schema description. The description partially compensates by noting property_id is optional and framing client_id as 'the client's' UTM spend source, but never explains what property_id selects (a GA4 property) or whether omitting it changes the result set.

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 concrete resource (GA4 performance by campaign UTM tags) and enumerates the metrics produced — sessions, key events, revenue, CPA/ROAS, attribution gap. It is clearly more specific than a generic performance report, though it never explicitly distinguishes itself from siblings like get_performance, tracking_audit, or search_console_report.

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

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

There is no explicit when-to-use/when-not statement or named alternative. Usage is only implied by the content list: 'attribution gap' and 'traffic without a campaign' hint at reconciliation work, but the agent must infer that this is the GA4-side counterpart to the ads performance tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so safety is covered and the bar is lower. The description does add real context beyond annotations: the scope of returned status (approved, executed, result) and the important caveat that platform delivery state for ad groups/ads is only present if the read happened after execution — a timing dependence an agent cannot get 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?

It is short, but the structure is weak: it is a sentence fragment beginning with a noun ('Status of a change proposal...') rather than leading with what the tool does. The conditional clause about delivery state is tacked on and reads as an afterthought rather than a clearly bracketed caveat.

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?

There is no output schema, so the description carries the burden of explaining return values — it does so partially, enumerating approval/execution/delivery dimensions but not the response shape or what happens for non-ad entities or unexecuted changes. Combined with the missing parameter explanation and workflow guidance, it is adequate but leaves clear gaps for a status-lookup tool embedded in a propose/approve workflow.

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

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

Schema description coverage is 0% and the single parameter change_id is a bare string in the schema, so the description must explain it — but it never mentions change_id, where it comes from (presumably the ID returned by propose_change), or what happens with an unknown ID. With one undocumented required parameter, 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 identifies the resource (a change proposal) and the information returned (approval status, execution outcome, delivery state), which lets an agent infer this is a status-read tool. However, it is written as a noun-phrase fragment with no verb — never stating that it retrieves/returns status given an ID — and it does not differentiate itself from siblings like approve_change, propose_change, or the *_changes tools.

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

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

There is no guidance on when to call this versus alternatives: nothing says it should be used after propose_change, or that approve_change is the mutation counterpart. The only conditional ('only when it was read after the change ran') describes a data caveat, not a usage rule, so the agent is left to infer the workflow entirely.

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

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

With annotations already covering the read-only, idempotent, and non-destructive nature, the description adds valuable behavioral context: null values mean 'unavailable' rather than zero, and preliminary days may still change. This goes beyond structured data without contradicting it.

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

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

The description is a single front-loaded sentence followed by two brief clarifications. Every sentence earns its place with no redundancy or 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?

No output schema exists, but the description lists the returned metrics, clarifies null semantics, and notes the preliminary days caveat. Date defaults are covered in the schema, and annotations handle safety. The definition is complete for correct invocation.

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

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

Schema description coverage is 67%; date_to and date_from are documented in the schema, but account_id is not. The description adds no parameter-level meaning beyond what the schema already provides, so a baseline 3 is appropriate.

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

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

The description states a clear purpose: retrieving account performance metrics (impressions, clicks, spend, conversions, CTR, CPC) by campaign for a period. It is specific about what the tool does but does not explicitly distinguish it from siblings like compare_periods or find_anomalies.

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 tool versus alternatives is provided. The description only describes the output, leaving the agent to infer the appropriate context from the name and 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds value beyond that by disclosing the shape of the content returned (server mechanics, tool inventory, and limits/constraints), which is exactly the behavioral context an agent needs for a guide tool. It stops short of stating whether the guide can become stale or how large the limits section is.

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 filler; the label 'Guide:' immediately frames the artifact and the rest enumerates its scope. Nothing here could be trimmed without losing information.

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

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

For a zero-parameter, no-output-schema onboarding tool whose annotations already carry the read-only safety profile, the description is nearly sufficient. It would be complete with one clause positioning it as the entry point relative to the other meta-tools (describe_tool, get_tool_schema, search_tools).

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to clarify or compensate for on this dimension.

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 artifact (a guide) and enumerates its contents: how the server works, which tools exist, and what the limits are. That distinguishes it reasonably from action-oriented siblings like create_campaign or get_performance, but it does not explicitly separate itself from adjacent meta-tools such as describe_tool, get_tool_schema, or search_tools.

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

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

Usage is implied rather than stated: an onboarding guide is naturally the first call, but the description never says 'call this first' or when to prefer describe_tool/get_tool_schema/search_tools instead. No exclusions or prerequisites 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 cover the safety profile (readOnly, idempotent, non-destructive, closed-world). The description adds genuinely new context by disclosing the shape of the return payload — parameter schema, write/reversibility/money-movement flags, and a concrete example call — which is useful since no output schema exists. It stops short of noting rate limits or pagination, but this is solid added value over the annotations.

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

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

It is a single compact fragment with no filler, which is good, but it is a sentence fragment lacking a leading verb, so it is not front-loaded around the action. Size is appropriate for the payload it describes.

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

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

With no output schema, the description carries the burden of explaining returns and does list the payload components and an example. However, it omits when to invoke it relative to describe_tool/search_tools and gives no hint of response structure beyond the enumeration. Adequate but with clear gaps.

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

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

Schema coverage is 0% and the single 'name' parameter is undocumented in the schema, so the description must compensate. It partly does by clarifying that the name can be an operation (with the concrete 'google_ads.get_structure' example) or a tool, but it doesn't state format expectations or how names are resolved. Marginal but real added 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 is a noun phrase listing the returned payload (parameter schema, flags, example call) rather than a verb stating what the tool does, though the name get_tool_schema and the payload list make the intent inferable. It does not differentiate itself from the sibling describe_tool, which plausibly serves a similar role. Purpose is understandable but not crisply stated or sibling-distinguished.

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 alternatives such as describe_tool or search_tools. It mentions that the target can be 'an operation (google_ads.get_structure) or a tool' but gives no condition for choosing this retrieval path. Usage must be entirely 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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the policy's content dimensions (autonomy level, limits, halted writes), which is useful behavioral context, but it says nothing about who may read the policy or how a 'stopped' state should affect subsequent calls.

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 subject front-loaded and no filler. It is appropriately sized, though it is descriptive rather than action-oriented.

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

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

With no output schema, the description carries the burden of conveying return content, and it does list the three policy dimensions returned. For a one-parameter read tool this is close to complete, with the main gap being the undocumented client_id parameter.

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

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

Schema description coverage is 0% and the single required parameter, client_id, is never mentioned in the description. The phrase 'the client's write policy' only loosely implies a client scoping parameter, adding minimal semantic value over the bare schema.

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

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

The description states a specific verb-implied resource (the client's write policy) and enumerates what it contains: autonomy level, change limits, and whether writes are stopped. That is concrete and distinct from read-oriented siblings like get_performance or client_overview, though no sibling is named 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?

There is no explicit when-to-use guidance, no statement of prerequisites, and no routing to alternatives (e.g., 'check before calling propose_change'). The agent must infer that this is a pre-flight check for write eligibility.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and idempotentHint=true, so the safety profile is structured data; the description reinforces it ("Changes nothing in the ad account") and adds the operationally important note that per-operation parameters must be fetched via get_tool_schema. It still omits pagination, rate limits, auth requirements, and return shapes, which is why it isn't 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?

The read-only framing and the get_tool_schema pointer are front-loaded where they matter, but the bulk of the text is a comma-separated list of 23 operation names that exactly duplicates the schema enum, adding length without adding meaning. Every operation is named; none is explained.

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 23-operation dispatcher with an undocumented open `params` object and no output schema, the description covers only the safety stance and where to find parameter docs. It says nothing about what any operation returns or how to pick between related operations (e.g. get_structure vs get_ad_details vs get_breakdowns), so an agent must make an extra get_tool_schema round-trip for every call.

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

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

Schema coverage is 0% and `params` is an untyped free-form object with no documentation at all. The description's only guidance is "Parameters of an operation: get_tool_schema", which defers the semantics to a second tool call rather than explaining them — a useful pointer, but it leaves the agent unable to populate `params` from this definition alone. The enum values are self-descriptive, which keeps this above a 1.

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 and mode ("Google Ads, read-only operations") and enumerates the 23 supported operations, so an agent knows exactly what capability surface this tool covers. It does not explicitly contrast itself with google_ads_changes or the cross-platform get_performance, but the 'read' framing makes the line reasonably clear.

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

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

Usage is only implied: 'read-only operations' plus the operation list tells the agent this is for pulling Google Ads data, and "Changes nothing in the ad account" hints that mutations belong elsewhere. There is no explicit when-to-use guidance, no statement that writes require propose_change/approve_change, and no help choosing among the 23 operations.

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

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

Beyond the destructiveHint/openWorldHint annotations, the description discloses important behavior: existing-object changes are proposals applied only after human approval or an auto policy for reversible changes, and new campaigns/ad sets/ads are created paused with no spend. It does not detail per-operation reversibility or failure modes, but it adds substantial context the annotations alone do not 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 core behavioral sentences are front-loaded and efficient, but the long enumeration of 21 operation names duplicates the enum already present in the input schema and consumes most of the description space. Removing or shortening that list would make the definition tighter.

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 multi-operation mutation tool with no output schema and a nested params object, the description covers the essential call context: the operation set, the proposal/approval model, paused creation, and where to look up per-operation parameters. It leaves some individual operation details to get_tool_schema, which is reasonable.

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

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

Schema description coverage is 0%, so the description carries more burden. It does not describe the params object or which fields each operation requires, but it does point the agent to get_tool_schema for per-operation parameters. That is useful compensation but stops short of true parameter semantics.

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

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

The description states a specific resource (Google Ads change operations) and enumerates the exact operation set, so an agent can distinguish this from read tools like google_ads and from sibling change tools for other ad platforms. The verb+resource framing 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?

It clearly establishes the context for use: applying changes to existing objects and creating new paused objects. It explains the approval/auto-policy condition under which proposals are applied, but does not explicitly name alternatives such as approve_change or get_change_status for follow-up actions.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the 'changes nothing' claim is redundant with structured data. The one genuinely additive behavior detail is the meta-workflow hint that operation parameters must be fetched via get_tool_schema; no auth, rate-limit, or return-shape context is given.

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?

Purpose is front-loaded, but the run-on enumeration of all 15 operations duplicates the enum already in the input schema and consumes most of the text without adding meaning. The closing get_tool_schema pointer is the only high-value sentence beyond the opening.

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 dispatcher with no output schema and 0% parameter coverage, the description leaves an agent unable to call any operation correctly without a second round-trip to get_tool_schema. It does at least make that dependency explicit, which keeps it at minimum-viable rather than inadequate.

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

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

Schema description coverage is 0% and the free-form 'params' object is entirely undocumented. The description merely re-lists the 15 enum values already present in the schema and defers all parameter meaning to get_tool_schema rather than compensating 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 resource (LinkedIn Ads) and scope (read-only operations) and enumerates all 15 supported operations. The line 'Changes nothing in the ad account' cleanly separates it from the linkedin_ads_changes sibling, though it doesn't explain what any individual operation returns.

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?

Signals that the tool is read-only and directs the agent to get_tool_schema for per-operation parameters, which is a useful pointer. However, there is no guidance on when to choose a given operation, when to prefer a sibling like get_performance or linkedin_ads_changes, or any prerequisites.

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

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

Goes beyond the annotations (destructiveHint=true, idempotentHint=false) by disclosing that existing-object changes are gated behind approval or a reversible-change auto policy, and that new campaigns/ad sets/ads are created paused with no spend. This materially clarifies the safety/reversibility profile. It does not, however, state what a rejection or partial-approval does.

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?

Front-loads the operation list, then the approval workflow, then creation semantics, then the parameter-lookup pointer. The operation enumeration is long but load-bearing; the sentences are tight and none is redundant.

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 dispatcher with no output schema and an opaque params object, the description covers the operation set, the approval/reversibility model, creation semantics, and where to find parameters. It stops short of connecting to get_change_status for tracking submitted proposals.

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

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

Schema description coverage is 0% and the nested 'params' object is entirely opaque, so the schema contributes nothing. The description partially compensates by pointing to get_tool_schema for operation parameters, which is a reasonable mitigation for a dispatch tool, but it never describes the shape of 'params' itself.

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 (LinkedIn Ads) and enumerates the ten change operations it dispatches, so an agent knows exactly what verbs are available. It is clearly distinguishable from the read-side linkedin_ads sibling by the 'change operations' framing, though it doesn't explicitly contrast itself with propose_change/approve_change.

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?

Explains the governing workflow: changes to existing objects are proposals applied only after human approval or when the client's auto policy permits a reversible change, and it directs the agent to get_tool_schema for per-operation parameters. It gives clear context for use but does not name alternative tools (e.g., approve_change, get_change_status) or state exclusions.

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

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, so safety is covered. The description's added value is enumerating the returned fields, which is useful given there is no output schema, but it says nothing about pagination, filtering on the returned statuses, or auth requirements. Modest incremental value over the annotations.

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

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

A single economical fragment with the resource front-loaded and zero filler. It is not padded, though its brevity 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?

For a simple read-only, single-parameter list tool with no output schema, the field enumeration partially substitutes for a return-value spec. Still missing are usage context, the source of client_id, and any note on how the listed 'supported change types' relate to the sibling change tools.

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

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

Schema description coverage is 0% and the description never mentions client_id or its format/source. The possessive 'The client's' only weakly implies the client_id parameter. With a low-coverage schema, the description fails to compensate for the missing parameter documentation.

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

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

The fragment 'The client's ad accounts' names the resource and the returned fields (platform, currency, connection status, supported change types), which distinguishes it loosely from siblings like list_campaigns and list_clients. However, it is a noun phrase rather than a verb+resource statement, so it never explicitly says the tool retrieves/lists accounts. Purpose is inferable but not stated outright.

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 prerequisite (e.g. that client_id must come from list_clients), and no mention of alternatives despite many sibling list_* and *_ads tools. The agent must guess the calling context entirely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered without the description. The description adds useful context about what is returned (status and daily budget expressed in minor units), but says nothing about pagination, ordering, or scope limits.

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

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

A single front-loaded sentence with no filler; the scoping subject and the returned fields are stated immediately. Nothing 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?

With no output schema, the description must carry return-value information; it names two fields (status, daily budget in minor units) but omits currency context, pagination, and whether all campaign types are included. Adequate but incomplete for a listing tool.

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

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

Schema description coverage is 0% and there is one required parameter, account_id, which the description never explains. Saying 'the account's campaigns' hints that the parameter scopes results to an account, but the format and source of that identifier are left entirely to the schema.

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

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

The description names the resource (the account's campaigns) and the fields returned (current status, daily budget), which lets an agent distinguish it from create_campaign and the *_ads reporting siblings. The verb is only implied by the plural noun phrase rather than stated as 'list', 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 when-to-use guidance, no mention of prerequisites (e.g., which account_id to supply), and no routing to alternatives such as list_accounts or create_campaign. The agent must infer usage 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 already establish readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description adds only the useful detail that results are filtered to what the user may access (permission scoping), with no mention of ordering, pagination, or result shape.

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

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

A single short sentence with no filler, and the scoping qualifier is placed at the end where it reads naturally. It is efficient, though arguably terse to the point of under-specification rather than maximally informative.

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

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

For a parameterless read-only list tool whose annotations cover safety, the description is minimally sufficient. However, with no output schema it never says what a client record looks like or how this list relates to list_accounts and client_overview, leaving a real gap about the return content and tool selection.

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 takes zero parameters, so the schema description baseline of 4 applies. There are no arguments whose semantics the description would need to supplement.

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 (the agency's clients) and hints at scope ("available to the user"), so an agent can infer it is a listing of clients. But it is a bare noun phrase with no verb and no differentiation from close siblings such as client_overview, list_accounts, or list_campaigns, so it does not fully stand apart from its 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?

There is no when-to-use guidance, no prerequisites, and no reference to the obvious alternative client_overview for per-client detail. The only implicit signal is the phrase "available to the user," which is a scope hint rather than 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, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered; the description's 'Changes nothing in the ad account' mostly restates it. The only genuinely additive behavioral detail is that per-operation parameters must be fetched via get_tool_schema, which is useful but thin given the annotations carry the rest.

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 purpose is front-loaded in the first clause, which is good. The bulk of the text is a 28-item enum that duplicates the schema's operation enum verbatim, so a large share of the description is not adding information the agent doesn't already have.

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 multiplexer exposing 28 distinct read operations with no output schema and a 0%-documented nested params object, the description provides no per-operation semantics or return-shape hints. Pointing to get_tool_schema is a valid escape hatch, but on its own it leaves the agent unable to choose an operation without an extra round trip.

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

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

Schema description coverage is 0%, so the description carries the full burden and largely fails it. It only points at another tool ('Parameters of an operation: get_tool_schema') instead of explaining the generic 'params' object, its nested shape, or what arguments each enum value expects.

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 class ('Meta Ads, read-only operations') and enumerates the 28 operations the tool dispatches, and the title plus 'read' framing distinguishes it from the sibling meta_ads_changes. However, the operation names are listed without any indication of what each one actually returns or does, so an agent still cannot tell operations apart from the description alone.

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?

'Changes nothing in the ad account' implicitly routes writes to meta_ads_changes, and 'Parameters of an operation: get_tool_schema' tells the agent how to obtain params before calling. There is no explicit when-to-use guidance for any individual operation, so the routing signal is implied rather than stated.

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

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

Annotations declare destructiveHint=true and openWorldHint=true; the description adds real context beyond that, clarifying that changes are applied only after human approval or an auto policy, and that new campaigns/audiences incur no spend. It still doesn't say what auto-policy limits are or what happens on rejection, 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?

The operation enumeration is long but necessary to expose the enum values, and the behavioral rules follow immediately after. The llm-facing content is front-loaded and there is little waste, though the flat comma list is denser than it needs to be.

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 multiplexed mutation tool with no output schema, the description covers the approval lifecycle, paused-creation behavior, and where to find per-operation parameters. It is nearly complete, with only return values and auto-policy specifics left 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?

Schema description coverage is 0% and params is an untyped free-form object, so the schema conveys nothing. The description compensates only by delegating to get_tool_schema, which is reasonable but gives no per-operation parameter meaning for 18 operations.

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 class of operations (change operations), then enumerates every enum value, so an agent knows exactly what this tool covers. It does not explicitly contrast with the sibling propose_change or meta_ads, 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?

It explains the proposal/approval model and that new objects start paused with no spend, which is useful context. But it never says when to pick this over the generic propose_change or the individual create_ad / create_campaign siblings, so the routing decision is 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 declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds a useful reinforcing constraint ('Changes nothing in the ad account') but discloses nothing further about rate limits, data freshness, or per-operation behavior, so it earns only modest credit above the annotations.

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

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

The purpose and read-only guarantee are front-loaded in the first clause, and the long operation list, while duplicating the schema enum, does aid discovery of what can be requested. It is dense but not padded with 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?

With no output schema and a nested free-form params object, the description covers the read-only nature and points to get_tool_schema, which is the minimum an agent needs. It does not describe the params object's structure or give any per-operation hints, so completeness is adequate but thin for a 23-operation dispatcher.

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

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

Schema coverage is 0%, so the schema itself explains neither the free-form 'params' object nor the operation semantics. The description compensates by listing the operation values (redundant with the enum) and by pointing to get_tool_schema for an operation's parameters, which is genuinely useful routing, but it still leaves the shape and contents of 'params' 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?

States a specific verb+resource ('Microsoft Advertising, read-only operations') and enumerates the 23 concrete operations, then explicitly contrasts with the sibling write tool by noting 'Changes nothing in the ad account.' The one gap is that it does not distinguish this from other read siblings like get_performance or google_ads, but the read/write boundary with microsoft_ads_changes is clear.

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

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

The description implies usage via 'read-only operations' and routes the agent to get_tool_schema for parameter details, which is a concrete next-step instruction. However, it never says when to pick this tool over alternatives such as get_performance, compare_periods, or the other platform read tools, and gives no exclusions.

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

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

Annotations already declare non-readonly, open-world, non-idempotent, destructive behavior. The description adds meaningful context beyond that: approval gating, reversible auto-policy limits, and the fact that created objects start paused with no spend. It does not cover auth requirements, rate limits, or return 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 front-loaded with the operation list and then immediately states the proposal/creation semantics. The long enum-like list is necessary for the tool's scope, and the remaining sentences are dense and purposeful.

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

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

For a complex 21-operation mutation tool with sparse schema coverage and no output schema, the description covers the key invocation context: operation list, proposal approval behavior, paused creation, and where to find per-operation parameters. A fuller definition would mention how to check approval/change status afterward, but the essentials are 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 coverage is 0%, so the description must carry parameter meaning. It does provide a useful pointer ('Parameters of an operation: get_tool_schema'), but it does not itself explain the shape or required fields of the nested 'params' object, leaving the agent dependent on a separate schema lookup.

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 pair ('Microsoft Advertising, change operations') and enumerates all 21 supported operations. This makes it clearly distinguishable from the read-oriented 'microsoft_ads' tool and from generic change siblings like 'propose_change'.

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 context: changes to existing objects are proposals that require approval or auto-policy allowance, and newly created campaigns/ad sets/ads are paused. It does not explicitly name when to use this versus 'propose_change' or the read 'microsoft_ads' tool, so it lacks explicit alternatives/exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered by structured data. The description's 'Changes nothing' line is largely redundant with readOnlyHint, and it discloses nothing about return format, pagination, rate limits, or auth needs, so it adds only the get_tool_schema routing hint.

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 compact paragraph, front-loaded with the read-only framing and ending with the actionable get_tool_schema hint. The long operation list duplicates the schema enum, which is mild redundancy, but nothing is wasted or buried.

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 13-operation dispatcher with a nested, undocumented params object and no output schema, the description is thin: it does not indicate what any operation returns or how to pick one. It mitigates this by pointing to get_tool_schema, but an agent still needs an extra call to use the tool competently.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. The operation enum values are self-documenting in the schema, but the free-form 'params' object is opaque; the description's note that operation parameters come from get_tool_schema is a genuinely useful pointer, though it stops short of describing expected param shapes.

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 (ChatGPT Ads) and scope (read-only operations), enumerating all 13 supported operations. Combined with the 'read' title, an agent can distinguish it from the write-side sibling openai_ads_changes, though the description never explicitly names that alternative.

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 states 'Changes nothing in the ad account,' which signals a read context, and routes parameter lookup to get_tool_schema. However, it gives no explicit criteria for choosing among the 13 operations or between this tool and alternatives like get_performance or google_ads.

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 destructive, open-world, non-idempotent behavior. The description adds meaningful context beyond that: existing-object changes are proposals requiring human approval or auto-policy allowance, and new campaigns/ad sets/ads are created paused with no spend. It does not cover rollback, permissions, or return behavior, but the safety model is substantially clarified.

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

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

The description is front-loaded with purpose and includes important behavioral notes, but the long operation enumeration duplicates the input schema's enum and consumes substantial space. Structure is clear, but some content does not earn its place.

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

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

For a complex 14-operation mutation router with 0% schema description coverage, no output schema, and nested parameters, the description covers the approval and paused-creation safety model well. However, it leaves per-operation parameter semantics and return behavior entirely to get_tool_schema, so it is not fully complete for correct invocation.

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

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

Schema description coverage is 0%, so the description needs to compensate for opaque parameters, but it only says to use get_tool_schema for an operation's parameters. It does not define the `params` object or explain what fields each operation requires; the operation list largely duplicates the enum.

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 domain and resource: ChatGPT Ads change operations, and enumerates the supported operations. It is clear this is a mutation tool, though it does not explicitly say how it differs from sibling read tool openai_ads or the generic propose_change.

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 operation list implies what each operation does, but there is no explicit guidance on when to use this tool versus openai_ads, propose_change, create_campaign, or other sibling tools. The approval/auto-policy sentence describes behavior, not selection criteria.

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

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

Annotations already declare write/destructive/non-idempotent/open-world, so the bar is lower, and the description still adds real context: which changes may apply immediately under limits, which always wait for human approval, and which can be undone. This reversibility and approval-flow detail is genuinely beyond what the annotations convey.

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

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

The content is dense and valuable, but it is delivered as one giant run-on paragraph with no headings, bullets, or front-loading of the kind→parameter mapping. An agent must parse the entire blob to find the variant it needs, which is poor structure for a 16-value enum.

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 23-parameter, no-output-schema tool this is remarkably thorough on per-kind behavior and approval semantics. It still omits what a successful call returns (a proposal id? a status?) and general field-level meaning for shared params, which for such a complex mutation tool is a notable 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 only 13% across 23 parameters, so the description must carry the load, and it does: it maps each kind to its required parameters, states minor units, sources (keyword ids from get_ad_group_keywords, assets from get_campaign_extensions), and expands bid-strategy enums (MAXIMIZE_CONVERSIONS with optional target_cpa_minor, etc.). Individual params like ad_id and budget_minor still lack per-field semantics, so it falls short of full compensation.

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

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

The opening clause states a specific verb and resource ('Create a campaign change proposal') and even explains the core behavioral distinction: the client's auto policy may apply a reversible change immediately or hold it for human approval. It is clearly a write/proposal tool, but the purpose is buried under an enormous enumeration of kind variants, and sibling routing (approve_change, get_change_status) is only implied.

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?

Useful per-kind prerequisites are scattered through the text ('read get_campaign_targeting first', 'from get_ad_group_keywords', 'from get_campaign_extensions'), and it distinguishes kinds that auto-apply from those that always wait for approval. However, there is no overarching when-to-use guidance and no explicit handoff to approve_change or get_change_status for the approval workflow it references.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description's 'Changes nothing in the ad account' largely restates readOnlyHint, but the pointer 'Parameters of an operation: get_tool_schema' adds a genuinely useful two-step workflow not captured in annotations. Modest value beyond structured data.

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 compact sentences, front-loaded with the resource and read-only scope. The operation enumeration is somewhat redundant with the schema enum, but the surrounding framing and the get_tool_schema pointer are efficient. 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 13-operation dispatcher with no output schema and an opaque params object, the description is reasonably complete: it frames the tool as read-only, lists the operations, and routes the agent to get_tool_schema for parameters. The main gap is per-operation intent, but the operation names are largely self-explanatory.

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

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

Schema coverage is 0%, so the schema does not document the two parameters. The description compensates by directing the agent to get_tool_schema for per-operation parameter details, which is meaningful given the opaque 'params' object. It does not, however, explain the shape or contents of 'params' directly.

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

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

The description names a specific resource (Reddit Ads) with an explicit scope qualifier ('read-only operations') and enumerates all 13 available operations. This distinguishes it from the write-oriented sibling reddit_ads_changes. It does not describe what individual operations do beyond their self-descriptive names, but as a router the purpose is clear.

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

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

The 'read-only' framing and 'Changes nothing in the ad account' imply usage (read/query scenarios) and implicitly contrast with the *_changes siblings, but there is no explicit when-to-use routing between the 13 operations or against alternatives like get_performance or get_tool_schema. Usage is implied rather than stated.

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

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

Annotations already flag destructive=true and readOnly=false, and the description adds genuinely new context beyond them: the approval gate, the auto-policy limits, and the paused/no-spend default for new objects. These are the exact behavioral facts an agent needs to reason about side effects that annotations alone cannot convey.

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

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

Front-loaded with the resource and the op list, then the proposal/paused semantics in two tight sentences. The eleven-operation enumeration is long but load-bearing; nothing here is 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?

Handles the highest-risk aspects (irreversibility, spend, approvals) for an eleven-operation destructive tool with no output schema, which is the right prioritization. Per-operation parameter shapes and the result of a proposal submission are left entirely to get_tool_schema and get_change_status, so it is adequate but not self-sufficient.

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

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

Schema coverage is 0% and the nested `params` object is entirely opaque — no field names, types, or per-operation shapes are given. The description only redirects to get_tool_schema, which is a procedural pointer rather than parameter semantics, leaving the agent unable to construct a call without an extra round trip.

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?

Names the exact resource ('Reddit Ads, change operations') and enumerates all eleven supported operations, so an agent knows precisely which mutations live here versus the read-side sibling reddit_ads. The scope statement ('a change to an existing object is a proposal; new objects are created paused') further pins down what kind of operation this is.

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

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

Provides real workflow context — proposals need human approval or an auto policy allowing reversible changes, and creations land paused with no spend — but never says when to prefer get_change_status, approve_change, or propose_change over this tool, nor when to use the read-side reddit_ads instead. The only explicit routing is 'Parameters of an operation: get_tool_schema'.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructiveness, so the safety profile is covered. The description adds real value by disclosing the included analyses (organic-in-top-3 overlap with paid terms, positions 4–20 without ads), but says nothing about row limits, data lag, or volume — typical unknowns for a Search Console pull.

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 front-loaded sentence that opens with the source and the core metrics, which is good. The semicolon-clause list of overlap analyses is dense and slightly hard to parse, but nothing is 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?

No output schema exists, so the description carries the burden of explaining returns; it lists the metrics and query/page breakdowns but omits shape, granularity (per-query vs aggregated), and volume limits. The site_url parameter remains entirely undocumented across both description and schema.

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

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

Schema coverage is only 50% and site_url has no description anywhere; the description only weakly implies it via 'the client's site'. Date semantics and defaults live entirely in the schema, so the description neither compensates for the gap nor clarifies how date windows interact with the 31-day cap.

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?

Names the source (Search Console) and enumerates concrete outputs: organic clicks, impressions, positions, top queries and pages, plus two overlap analyses. That is enough to tell it apart from ga4_report and google_ads, though the 'report' verb is only implied by 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?

No statement of when to choose this over ga4_report, google_ads, or get_performance, and no exclusions or prerequisites. The only usage signal is implicit scoping to organic Search Console data for a client's site.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context — the catalog is searchable in Ukrainian as well as English — but says nothing about result format, ranking, or result limits.

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

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

A single front-loaded sentence covering both the resource and both parameters, with no padding. The only blemish is the erroneous 'amazon' entry, which is a correctness issue rather than a length issue.

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 search tool with no output schema, the description omits what the results look like (tool names? schemas? operation IDs?) and any result-count behavior, which an agent needs to chain into describe_tool. The parameter list and the catalog scope are otherwise adequately covered.

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

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

Schema coverage is 0%, so the description must carry the parameter burden. It does explain that query takes words (and adds the Ukrainian/English detail absent from the schema), but its platform list is a near-duplicate of the enum and wrongly includes 'amazon', which the schema does not allow — introducing ambiguity rather than resolving it.

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 (search) and resource (catalog tools and operations), so an agent knows it queries the tool catalog. It does not explicitly differentiate itself from sibling catalog tools like describe_tool or get_tool_schema, which is the only thing keeping 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 and no mention of alternatives, despite siblings describe_tool and get_tool_schema occupying the same discovery space. The agent must infer that this is the discovery entry point rather than being told.

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?

"Changes nothing in the ad account" restates what readOnlyHint/destructiveHint already declare, so it adds little. Its one real contribution is the workflow note that per-operation parameters live behind get_tool_schema, but it says nothing about pagination, rate limits, or account-scope requirements for a tool marked openWorldHint.

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?

Front-loads the resource and read-only scope, then a single enumeration sentence, then the parameter-discovery pointer. Minimal waste, though the long inline operation list is dense and would read better as a compact bulleted or grouped listing.

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?

As a dispatcher with no output schema and zero schema coverage, the description does the essential work of enumerating operations and deferring parameter discovery to get_tool_schema. It remains incomplete on distinguishing snapchat_ads from snapchat_ads_changes and on what each operation returns, which an agent still cannot determine from the definition alone.

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

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

Schema description coverage is 0% and the nested `params` object is entirely undocumented, so the schema carries no parameter meaning. The description partially compensates by listing the valid operation values and pointing to get_tool_schema for per-operation arguments, which is genuine routing value but stops short of describing what any operation actually requires.

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?

Names the resource (Snapchat Ads) and scopes it as read-only, then enumerates the thirteen supported operations, which is enough for an agent to distinguish this dispatcher from the write-oriented sibling snapchat_ads_changes. It never explicitly names that sibling as the mutation counterpart, 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?

The operation list maps tasks to entry points and the closing line tells the agent how to obtain parameters, which is useful routing guidance. However, there is no explicit statement of when to use this tool versus snapchat_ads_changes or the platform-agnostic siblings like get_performance, leaving selection partly inferential.

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 substantive behavior beyond annotations: approval-gated application, auto-policy limits/reversibility, and paused/no-spend creation. Annotations already cover destructive/read-only/idempotency, and the description does not contradict them. It omits return/status behavior and any auth/rate-limit details.

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?

Front-loads purpose and behavior in a compact set of sentences, with no filler. The long operation enumeration is somewhat redundant with the enum in the schema but still readable and scoped.

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

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

Covers the essential proposal/creation workflow and points to get_tool_schema, which is enough to start discovery. However, for a 13-operation mutation dispatcher with no output schema and no per-operation parameter descriptions, it omits return values, follow-up status checks, and explicit routing to approve/status tools.

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

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

The only parameter-related guidance is that operation parameters come from get_tool_schema; the actual semantics of params and per-operation requirements are absent. The operation list merely repeats the schema enum, and schema coverage is 0% for the nested params object.

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?

Names the resource and operation family explicitly and enumerates the supported changes, so an agent can see this is the Snapchat Ads mutation entry point. It does not explicitly route reads to snapchat_ads or generic proposals to propose_change, so it falls 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?

Explains the key usage condition: existing-object changes are proposals that require approval or auto-policy eligibility, and new objects are created paused. It also directs agents to get_tool_schema for operation parameters. It does not name when to prefer snapchat_ads, approve_change, or get_change_status.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so safety is fully covered structurally. The description mostly restates this ('read-only', 'changes nothing') and adds only the operation inventory plus the get_tool_schema routing hint, not richer behavioral context like return shape or pagination.

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?

Purpose is front-loaded, followed by the operation inventory and the key read-only constraint. The long operation list is dense but necessary given there is no per-operation schema, and no sentence is 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 13-operation dispatcher with nested objects, no output schema, and 0% parameter coverage, the description is thin: it names operations but explains none of their inputs, outputs, or distinctions. The get_tool_schema pointer is the main completeness feature, but per-operation context is deferred entirely.

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

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

Schema coverage is 0%, so the description carries the burden. It partially compensates by telling the agent where to find per-operation parameters (get_tool_schema), but gives no semantics for the enum values or the 'params' object format, leaving the agent dependent on a second call.

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 ('TikTok Ads, read-only operations') and enumerates all 13 supported operations. An agent can tell this is the read counterpart to tiktok_ads_changes, though the sibling is never named 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?

'Changes nothing in the ad account' implies read-only usage and contrasts implicitly with the write sibling, but there is no explicit when-to-use / when-not guidance or named alternative. The pointer to get_tool_schema hints at a discovery workflow but isn't framed as a usage 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, but the description adds significant behavioral context: changes are proposals applied only after human approval or auto-policy, and creations are paused with no spend. It also points to get_tool_schema for operation parameters, though it omits auth requirements and rate limits.

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

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

The description is a single, front-loaded paragraph that lists operations, then explains proposal/creation behavior, then points to get_tool_schema. Every sentence contributes necessary information, though the operation list is long and could be slightly better structured.

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 14 operations, no output schema, and 0% schema description coverage, the description adequately covers the overall proposal/approval model and the paused-creation behavior, and it directs the agent to get_tool_schema for per-operation parameters. It does not describe return values or how to check proposal status, but those gaps are minor for a dispatcher tool.

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

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

Schema description coverage is 0%, and the description only says 'Parameters of an operation: get_tool_schema.' It lists the operation enum values (already in the schema) but gives no meaning for the nested params object. Delegating to another tool is helpful but does not compensate for the lack of parameter semantics in the description itself.

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 'TikTok Ads, change operations' and enumerates all supported operations, giving a specific verb (change) and resource (TikTok Ads) with clear scope. It distinguishes itself from the read-only tiktok_ads sibling by naming the platform and listing mutation operations, although it does not explicitly reference alternatives like tiktok_ads or propose_change.

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 critical context that changes to existing objects are proposals requiring approval or auto-policy, and that new objects are created paused. However, it does not explicitly state when to use this tool vs. sibling alternatives such as propose_change, approve_change, or get_change_status; usage is implied by the platform and operation list.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that the result includes diagnostics and remediation suggestions ('what to fix'), which is useful return-shape context, but it says nothing about scope, caching, or freshness beyond 'latest'.

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 efficient sentence with the resource front-loaded and the covered areas scannable. Slightly dense but no wasted clauses.

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

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

With no output schema, the description does convey the rough return contents (status per area, fixes). However, with 0% param coverage and an undocumented url argument, an agent lacks enough to know whether to pass url or how results are scoped.

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

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

Schema description coverage is 0%, so the description must carry the param burden. It only alludes to 'the client' (client_id) and says nothing at all about the optional url parameter — when to supply it, or how it interacts with client_id.

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

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

States a specific resource (website tracking audit) and enumerates the covered areas — tags, GA4, conversions, pixel — plus the returned value (status and fixes). It is clearly distinguishable from report siblings like ga4_report, though it doesn't explicitly say so.

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 word 'latest' implies a retrieval of an existing audit, but there is no statement of when to use this versus ga4_report, search_console_report, or find_anomalies, nor any precondition (e.g., audit must have been run). Guidance is essentially absent.

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