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

With no annotations, the description carries the full burden, and it does disclose one meaningful trait: the earliest valid event month per user becomes the acquisition cohort, plus the expected input fields. However, it omits what 'valid' means, how invalid/missing dates are handled, and timezone/aggregation behavior, leaving notable gaps for a computation 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?

Three short sentences, front-loaded with the outcome followed by input requirements and the cohort rule. Every sentence earns its place with no filler.

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

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

An output schema exists, so return values need not be explained, and the description covers input shape and the core cohort semantics. It is close to complete, missing only edge-case handling for malformed or missing event fields.

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 parameter is an opaque array with additionalProperties, so the schema alone conveys nothing. The description compensates well by naming the required field names (user_id, event_date/date, event_name) and the accepted date-field aliases, though it doesn't state required vs optional per field.

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: it calculates cohort sizes and month-level retention, with a clear input domain (user event records). No sibling in the list performs cohort analysis, but the description never explicitly distinguishes itself from adjacent analytics tools like calculate_growth_metrics or analyze_growth_query, so it stops 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 explicit when-to-use or when-not-to-use guidance, and no alternatives are named among the many analytics siblings. The only contextual help is the cohort definition, which is behavioral rather than selection guidance.

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

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

With no annotations, the description carries the full behavioral burden. It discloses one trait (no ranking of creatives), but omits whether this is read-only, what permissions are needed, and how it handles the input. One behavioral hint is insufficient for an unannotated 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?

A single front-loaded sentence with no wasted words. It is efficient, though arguably too sparse for a tool with an opaque required parameter, which keeps it just short of a 5.

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

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

An output schema exists so return values need not be explained, but the description is otherwise thin: no annotations, no usage guidance, and a fully undocumented required array parameter. For a tool of this complexity the definition is not complete enough for reliable 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?

The single required parameter 'records' is an array of untyped objects with additionalProperties=true and 0% schema description coverage. The description never mentions records or its expected shape, so it fails to compensate for the schema gap that the agent needs to construct a valid 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?

States a specific verb (analyze) and resource (creatives) plus the metric scope (delivery and acquisition). The clause 'without ranking creatives' narrows it, but it does not name or contrast with any sibling such as compare_campaign_metrics or analyze_cohorts, so an agent still has to infer where this fits.

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 named alternative among the many analysis siblings. 'Without ranking creatives' is a scope constraint, not a usage rule, and it does not tell the agent when this tool is the right choice.

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 no annotations, the description carries the full behavioral burden. It does disclose something valuable and non-obvious: the response includes the exact filtered record count and calculation metadata for auditing, implying a deterministic, inspectable read operation. It does not state that records are left unmodified, whether the tool requires auth, or any cost/latency characteristics.

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 core purpose in the first sentence, followed by scannable lists of filters and metrics. The enumeration of metrics is long but earns its place by telling the agent what questions are answerable. Minor redundancy between the filter list and the general capability statement.

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

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

An output schema exists so return values need not be re-explained, and the description adds useful scope on filters, metrics, and audit metadata. However, with 0% schema coverage on three parameters, an unclear `source` input, and no sibling routing guidance, an agent is left guessing on several call-critical details.

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

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

Schema coverage is 0% for three parameters, so the description is the only source of parameter meaning. 'Natural-language ... question' loosely maps to `query` and 'over supplied records' loosely maps to `records`, but the `source` parameter (default 'client-supplied') is entirely unexplained, as is the expected shape of `records` objects. The description only partially compensates for the coverage gap.

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

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

States a specific verb and resource: 'Answer a natural-language growth analytics question over supplied records.' An agent can distinguish this from siblings like calculate_growth_metrics or compare_campaign_metrics because the input is free-text plus analyst-supplied records. It does not, however, name the sibling it competes with, so routing still requires inference.

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

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

The description scopes the tool usefully by listing supported filters (campaign names, platforms, ISO date ranges) and supported metrics (ROAS, revenue, CTR, etc.), which lets an agent judge whether a given question fits. But it gives no explicit when-to-use vs. when-not guidance and never points at the alternative sibling tools for non-natural-language or non-supplied-record cases.

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?

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the tool persists anything, requires specific permissions, is idempotent, or how 'source' defaults are applied. It only conveys that output is a 'compact audit packet,' leaving key behavioral traits undisclosed.

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 that front-loads the verb and resource with no wasted words. It is well-sized, though the brevity leaves the tool under-explained given its complexity.

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

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

An output schema exists so return values need not be described, but with three parameters at 0% schema coverage and no annotations, the description omits too much. An agent lacks the input format and behavioral context needed to invoke it confidently.

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

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

With 0% schema description coverage, the description must compensate but largely does not. It loosely maps 'business question' to the question param and hints at records via 'source rows,' but gives no format, structure, or meaning for records, question, or the source parameter's default value.

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

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

The description pairs a specific verb (create) with a concrete resource (a compact audit packet) and notes its content (tying a business question to source rows and calculations). This differentiates it from siblings like analyze_growth_query or investigate_campaign without naming them. It is clear, though 'audit packet' remains somewhat abstract.

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

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

There is no guidance on when to use this tool versus alternatives such as build-adjacent analysis tools (analyze_growth_query, investigate_campaign, normalize_growth_records) or when it should not be used. The audit/packet framing implies a context, but no explicit conditions or alternatives are 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?

No annotations are provided, so the description carries the full behavioral burden, yet it only says what is computed, not that the operation is a side-effect-free read, what happens with malformed or partial records, or how missing fields are treated. Minimal disclosure for a tool with zero structured behavioral hints.

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

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

A single efficient sentence with the verb and outputs front-loaded and no filler. It is tight, though the brevity contributes to the documentation gaps rather than being purely a virtue.

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

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

An output schema exists, so return values do not need explaining, and the metrics list tells the agent what comes back. The gap is the input: with no record-field guidance anywhere, an agent cannot reliably construct the 'records' payload, which is a meaningful omission for a computation 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?

The schema has 0% description coverage and the single 'records' parameter is untyped in spirit (array of free-form objects). The description says metrics are computed 'for records' but never explains which fields each record must contain (impressions, clicks, spend, conversions) to produce CTR/CPC/ROAS, leaving the critical input contract undocumented.

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

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

States a clear verb (calculate) and enumerates the specific metrics produced (CTR, CPC, CPA, CPL, conversion rate, ROAS), so the resource is unambiguous. However, it offers no differentiation from siblings that also touch metrics, such as compare_campaign_metrics, normalize_growth_records, or analyze_growth_query.

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 indication of when to use this tool versus compare_campaign_metrics, analyze_growth_query, or normalize_growth_records, nor any prerequisite about state or inputs. The agent is left to infer usage 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?

No annotations are provided, so the description carries the full burden. It usefully discloses one behavioral trait — that output is neither ranked nor accompanied by a recommendation — and 'compare' implies a non-mutating read. However, it says nothing about permissions, whether metric values are normalized across campaigns, or error behavior when a campaign lacks the metric.

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 constraining clause comes after the core action, and every word earns its place.

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

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

An output schema exists, so return values need not be described. That leaves a two-parameter read tool with 0% parameter coverage and no usage routing, which is roughly the minimum viable level of completeness.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters, and it largely does not. It hints at a 'metric' dimension but never names the default (roas) or explains the required 'campaigns' array element shape (additionalProperties: true, so its structure is entirely undocumented elsewhere).

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

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

States a specific verb ('compare') and resource ('campaign metric values'), and scopes the operation by excluding ranking/recommendation, which cleanly separates it from investigation-oriented siblings like investigate_campaign or analyze_growth_query. It does not name a sibling directly, so 4 rather than 5.

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

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

The clause 'without ranking or recommending' implicitly tells the agent when this tool is the right fit (raw side-by-side comparison rather than advice), but there is no explicit when-to-use statement, no prerequisites, and no named alternative for the ranking/recommendation case.

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?

No annotations are provided, so the description carries the full burden. It discloses the algorithm (largest centered region, equivalent to 'Original' crop) and validation notes for invalid keys. It does not explicitly state read-only nature or absence of API calls, but 'compute' implies a pure function with no side effects.

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

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

The description is well-structured with Args and Returns sections, front-loading the purpose. It is appropriately sized for the complexity, and every line, including the crop key list, adds necessary value without redundancy.

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

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

Despite lacking annotations, the description fully covers purpose, usage, parameter details, output format, and validation behavior. It is complete enough for an agent to select and invoke the tool correctly, even with the output schema.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining each parameter with examples and enumerating all crop_keys options, including aspect ratios and placements. This goes well beyond the schema's simple field titles.

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

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

The description clearly states it computes image_crops coordinates for a source image of given dimensions, with a specific verb and resource. It also explains the output's direct use in create_ad_creative, distinguishing it from sibling tools focused on account, campaign, and creative management.

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

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

The description provides context by stating the result is ready to pass directly to create_ad_creative or bulk_create_ad_creatives, indicating when to use it. It does not explicitly list exclusions or alternatives, but the unique purpose among siblings makes the use case clear.

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

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

With no annotations, the description carries the transparency burden. It discloses the Dynamic Creative prerequisite and error_subcode 1885998, and mentions cached token behavior for access_token. It lacks details on return values, but the output schema covers that.

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

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

The description is concise and well-structured: a one-sentence purpose, an Args list, and a Note. Each line provides necessary information without fluff or redundancy.

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

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

Given the tool has 8 parameters and no schema descriptions, the description covers all parameters, specifies a failure condition, and explains token fallback. It lacks explicit usage comparisons, but the purpose is clear and the output schema exists for return details.

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

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

Schema description coverage is 0%, but the tool description provides detailed, helpful descriptions for every parameter, including the account_id format, an example for tracking_specs, and the default for status. This fully compensates for the schema's lack of descriptions.

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

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

The description starts with 'Create a new ad with an existing creative,' which clearly states the verb (create), resource (ad), and a key constraint (existing creative). This distinguishes it from sibling tools like create_ad_creative and create_campaign.

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

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

The description implies usage when an existing creative is available, and the Dynamic Creative note adds a prerequisite. However, it does not explicitly compare against alternatives or state when not to use this tool.

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

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

With no annotations to lean on, the description over-delivers on behavior: it discloses Meta error codes (1487390, 1885800, 1443048), silent multi-hash collapse in DOF mode, automatic routing through asset_feed_spec, the thumbnail transcode race with video_status 'processing', and enum-rejection behavior for free-form CTA values. This is exactly the operational knowledge 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 front-loaded with a mode overview before the long Args block, and the length is largely justified by the 35-parameter surface. There is minor redundancy — asset_customization_rules is effectively defined twice (once inside the PLACEMENT mode bullet and again in the Args list) — which keeps it from a 5.

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

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

An output schema exists, so return-value explanation is correctly omitted ('JSON response with created creative details'). Given 35 parameters, zero schema descriptions, no enums, and no annotations, the description supplies essentially everything needed to assemble a correct request.

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 semantic burden, and it does so for nearly every parameter: mutual-exclusivity rules (image_hash vs image_hashes vs video_id), required/format constraints (account_id as act_XXXXXXXXX, E.164 phone, object_story_id format), example payloads, and default-value logic for ad_formats. This is far above the compensation threshold the low coverage demands.

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 sentence states a specific verb and resource ('Create a new ad creative') plus the three input families it accepts (image hash, video ID, existing post). It is immediately distinguishable from siblings like update_ad_creative, get_ad_creatives, and create_ad, and the six enumerated modes make the tool's scope unambiguous.

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

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

The description gives exhaustive condition-based guidance for selecting among six creative modes, including when is_dynamic_creative or optimization_type is and is not required. It does not, however, route the agent against sibling tools (e.g., when to use update_ad_creative instead), so it stops short of full when/when-not/alternatives coverage.

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 no annotations provided, the description carries full behavioral disclosure. It reveals defaults (status=PAUSED, advantage_audience=0), immutability (promoted_object, frequency_control_specs), error subcodes (1885154, 1815715, 1815198), API limitations (ON_AD rejection, profile/page visits not supported), and CBO inheritance behavior. This goes far beyond basic description.

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

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

The description is long but appropriately sized for 26 parameters. It is front-loaded with a clear purpose, then organized into per-parameter blocks. Minor redundancy exists (CBO note repeated for daily_budget and lifetime_budget), but overall each sentence adds essential information.

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

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

Given the complexity of 26 parameters and no schema descriptions, the description comprehensively covers all parameter semantics, valid values, required combinations, error cases, and practical examples. It even addresses edge cases like EU DSA compliance and regional regulations, leaving no major gaps for an agent to fall into.

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

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

Schema description coverage is 0%, so the description must compensate — and it does exceptionally. Every parameter gets format, units (cents), valid values, dependencies, and often concrete examples. It explains precise semantics like lowcost minimization for bid_strategy, budget inheritance, and targeting automation defaults, making parameter usage unambiguous.

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

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

The description opens with 'Create a new ad set in a Meta Ads account' — a specific verb and resource that clearly distinguishes it from sibling tools like update_adset or create_campaign. The extensive parameter details reinforce the exact purpose without ambiguity.

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

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

The description provides clear context on when to use the tool and when to avoid certain settings (e.g., CBO budget notes, bid strategy requirements, optimization_goal constraints). It doesn't explicitly name alternatives like update_adset, but the creation-specific guidance is strong enough to guide correct usage.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It states the operation ('Create') and return format (JSON string with ID or error), but does not mention permissions, idempotency, reversibility, or effects on existing schedules. For a mutation tool, this is a significant gap in behavioral transparency.

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

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

The description is concise and well-structured. It front-loads the purpose, then lists arguments in a clear Args block, and ends with the return value. Every sentence serves a purpose, with no redundant or filler content.

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

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

The description covers all parameters and the return value, and an output schema is present. However, for a create-type tool with no annotations, it lacks guidance on prerequisites, permissions, or edge cases (e.g., overlapping schedules, budget limits). It is adequate but leaves gaps that an agent would need to infer.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain each parameter: campaign_id, budget_value, budget_value_type (with 'ABSOLUTE' or 'MULTIPLIER' values), time_start/end (Unix timestamps), and access_token (optional, cached token). However, it leaves ambiguity around what MULTIPLIER means exactly and how budget_value is interpreted for each type, so it is helpful but not complete.

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 begins with a specific verb+resource: 'Create a budget schedule for a Meta Ads campaign.' It clearly states the tool's function and distinguishes it from sibling tools, none of which mention budget scheduling. The second sentence adds the specific purpose of scheduling increases for high-demand periods.

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

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

The description provides a clear context for when to use the tool: 'Allows scheduling budget increases based on anticipated high-demand periods.' It does not explicitly mention alternatives or exclusions, but the context is sufficiently distinct from the other tools in the list. The optional access_token behavior is also 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?

With no annotations provided, the description carries the full transparency burden and excels. It discloses the return value (new campaign id), a critical constraint (start_time not supported on campaigns), error conditions (legacy objectives cause 400 errors), and interdependencies (certain bid strategies require bid_amount on child ad sets). It also explains budget semantics (cents, ABO vs CBO) and defaults.

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

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

The description is long but appropriately structured for a tool with 15 parameters. It front-loads the core purpose, then provides a note and a well-organized Args section. Some redundancy exists (e.g., 'Also known as' list and repeated mention of campaign group), but it does not detract from usability.

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

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

Given the tool's complexity (15 parameters, no annotations, no schema descriptions), the description is remarkably complete. It covers all parameter semantics, return value, error behaviors, the broader campaign hierarchy, and special considerations like A/B testing and special ad categories. The output schema further reduces the need to describe return structure.

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 fully compensate—and it does. Every parameter is explained with type, format, valid values, defaults, or usage context. For example, objective lists valid ODAX values and warns against legacy values, bid_strategy enumerates options and flags child ad set requirements, and budgets clarify they are in cents.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Create a new Facebook or Instagram ad campaign in a Meta Ads account.' It also distinguishes itself from sibling tools by noting it is 'the first step of the campaign group → ad set → ad hierarchy,' which separates it from create_adset and 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?

The description provides clear context for when to use the tool ('Use this to start a new campaign') and includes practical guidance like setting start_time on the ad set instead. However, it does not explicitly name alternative tools for different operations (e.g., update_campaign for modifications), so exclusions are 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?

No annotations are provided, so the description carries the full burden. It discloses the algorithmic approach (z-score threshold) but remains silent on side effects, read-only nature, authentication needs, and output shape (though an output schema exists). It adds some behavioral context but leaves notable gaps.

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

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

A single, front-loaded sentence with no filler. Every word contributes to conveying the tool's purpose and method.

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

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

With an output schema, return values needn't be explained, and the tool is simple (two params). However, the description omits usage context, parameter detail, and any behavioral traits, leaving it merely adequate for an agent to invoke correctly without deeper understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It only indirectly references 'observations' (values) and 'z-score threshold' (z_threshold) without explaining formats, defaults (2 is only in the schema), or what the array should contain. This is minimal compensation for fully undocumented parameters.

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

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

The description states a specific verb ('Flag') and resource ('observations') plus the method ('z-score threshold'), making the function clear. It does not explicitly distinguish itself from sibling analysis tools like calculate_growth_metrics or investigate_growth_issue, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus its siblings, nor any exclusions or prerequisites. The phrase 'using a z-score threshold' implies a statistical context but does not tell an agent when this tool is the right choice over alternatives like analyze_growth_query or investigate_campaign.

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 no annotations, the description carries the full burden: it does disclose a real behavioral trait (the copy is created PAUSED by default, with the automation rationale), which is non-obvious and valuable. However, it omits auth requirements (the access_token param), the write/create nature of the operation, and what deep_copy's default of true actually causes.

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

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

Two short paragraphs, front-loaded with the verb and resource before the caveat. No filler, no restatement of the name.

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

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

An output schema exists, so return values need not be described, but the five undocumented parameters (notably deep_copy's default of true) leave an agent without enough to call the tool confidently. The definition is thin for a tool that mutates state.

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

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

Schema description coverage is 0% across five parameters, and the description names none of them. 'Created paused by default' gestures at status_option but never ties it to the parameter, and new_name, deep_copy, and access_token are entirely unexplained in both schema and prose.

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 (duplicate) and resource (Meta campaign) plus the mechanism (Graph API), which is enough to separate it from create_campaign and update_campaign. It stops short of explicitly contrasting itself with those siblings or clarifying that it copies an existing campaign's configuration rather than authoring a new one.

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

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

Implies the automation use case (safe duplication the caller can verify before enabling delivery) but never states when to pick this over create_campaign or when duplication is inappropriate. The rationale for rounding is left for the agent to infer.

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 no annotations provided, the description carries the burden. It discloses behavioral traits such as optional access_token with cached token fallback, account_id being required for comprehensive estimation, and deprecated parameters. It does not explicitly state side effects or rate limits, but the 'estimate' action implies read-only behavior. The disclosure is reasonably thorough.

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 organized with an intro, Args block, and Returns section. It is somewhat long but each sentence serves a purpose. The example for targeting is illustrative, and deprecated notes are clearly marked. A minor redundancy is the 'This function provides...' sentence which could be implicit, but overall structure is efficient.

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

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

Given the six-parameter complexity, zero annotations, and no schema descriptions, the description covers every parameter, provides an example, notes defaults, explains the return value, and flags deprecated fields. It even mentions the API name. This is sufficient for an agent to select and invoke the tool effectively.

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 explain all parameters. It does so thoroughly: access_token (cached fallback), account_id (format and requirement), targeting (with a full example), optimization_goal (default and options), and interest_list/interest_fbid_list (deprecated). This adds substantial meaning 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?

The description opens with a specific verb+resource: 'Estimate audience size for targeting specifications using Meta's delivery_estimate API.' This clearly states what the tool does and distinguishes it from sibling tools like search_interests or search_behaviors, which are search utilities rather than estimation endpoints.

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

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

Provides clear context: the tool is for comprehensive audience estimation for complex targeting combinations, and also maintains backwards compatibility for simple interest validation. This implies when it should be used (complex targeting) and notes the deprecated fallback usage. However, it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses that access_token is optional and uses a cached token if omitted, that fields replace the default set, and it explains the precise meaning of 'balance' for prepaid accounts (common in Brazil). This goes well beyond basic read-only behavior and provides critical financial semantics.

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

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

The description is well-structured with a concise opening and structured Args breakdown. Every sentence adds valuable detail—especially the prepaid account note about Brazilian accounts—without excessive padding or repetition. It is appropriately sized for the tool's complexity.

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

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

Given the tool's simplicity (3 params, output schema present), the description is exceedingly complete. It covers parameter formats, defaults, field replacement semantics, and a geographic edge case. The output schema handles return values, so the description's job is to provide usage context, which it does exceptionally.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It does so thoroughly: account_id includes the required format, access_token explains its optionality, and fields not only lists examples but explains that they replace the defaults and describes the default field set. It even clarifies edge-case behavior for prepaid accounts.

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

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

The description opens with 'Get detailed information about a specific ad account,' which clearly states the verb, resource, and scope. The use of 'specific' distinguishes it from sibling tools like get_ad_accounts (which lists accounts), making the tool's purpose unambiguous.

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

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

The description provides clear context for fetching a single account's details, including the optional access_token and customizable fields. It never explicitly names alternative tools for listing accounts or says when not to use this tool, but the 'specific' wording strongly implies its appropriate use case.

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 no annotations, the description carries the burden. It adds useful context by specifying the account_id format (act_XXXXXXXXX) and disclosing access_token is optional and will use a cached token when not provided. However, it lacks details on permissions, error cases, or pagination, leaving some behavioral aspects undisclosed.

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

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

The description is concise and well-structured: a one-line purpose, an Args section with clear parameter explanations, and a Returns line. No fluff, and the main purpose is front-loaded.

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

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

For a simple 2-parameter read tool with no annotations and an assumed output schema, the description covers the essential information: what it does, parameter formats, and return type. It lacks only extended usage guidance and behavioral depth, which are minor for this tool. The presence of an output schema alleviates the need to detail the return structure.

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

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

The schema has no descriptions (0% coverage), and the description compensates fully. It explains account_id format and the optional/fallback behavior of access_token, adding meaning beyond the raw schema properties.

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

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

The description clearly states the tool's function with a specific verb and resource: 'Get pages associated with a Meta Ads account.' It distinguishes from siblings like get_account_info (account info) and get_page_posts (posts on a page) by focusing on pages tied to an ad account.

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 by the clear purpose: an agent would invoke this when needing pages linked to a Meta Ads account. However, there is no explicit comparison to alternatives or when-not-to-use guidance, so it stops at implied usage without 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 are absent, so the description must carry the full burden. It provides useful behavioral details: currency units (not cents), optional access_token with caching, and default limit. However, it doesn't explicitly state read-only behavior, rate limits, error cases, or other side effects. Given the lack of annotations, this is incomplete but not misleading.

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 concisely structured with a main line, a units note, and an Args list. Every section earns its place, though the Args list format could be slightly tightened. It avoids redundant filler and is well-organized.

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 list operation with an output schema present, the description covers the essential aspects: parameters, defaults, token caching, and units for specific returned fields. It does not delve into pagination or error handling, but given the existence of an output schema and the simplicity of a get, it is adequately complete.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining each parameter: access_token (optional, cached), user_id (Meta user ID or 'me'), and limit (default 200). This adds meaning significantly beyond the schema's type/default definitions.

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

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

The description starts with a clear verb+resource: 'Get ad accounts accessible by a user.' This specifically identifies the tool's function and distinguishes it from sibling tools like get_account_pages (pages) and get_account_info (likely a single account). The resource and scope are 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?

No guidance is provided on when to use this tool versus alternatives. While the purpose is clear, there is no mention of alternatives, exclusions, or specific scenarios (e.g., 'use this when you need a list of all accounts'). The description relies solely on the name and first line to convey usage context.

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

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

With no annotations, the description carries the transparency burden. It discloses that access_token is optional and will use a cached token if not provided, which is useful. It also notes the ad_id requirement. However, it does not explicitly state whether the operation is read-only, nor does it mention error cases or rate limits, leaving some behavioral traits undisclosed.

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

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

The description is concise (two lines plus an args list) with the purpose stated upfront. Every sentence adds value, including the workflow hint and parameter details. No redundant information is present.

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 getter with an output schema, the description covers purpose, usage, and parameters adequately. It includes a helpful pointer to get_ads and clarifies the required input. It does not mention error handling or edge cases, but given the tool's simplicity and existing output schema, it is largely complete.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining each parameter: ad_id is 'Meta Ads ad ID (required)' and access_token is 'Meta API access token (optional - will use cached token if not provided)'. This adds meaningful context beyond the schema's type/required fields.

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

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

The description clearly states 'Get creative details for a specific ad' with a specific verb and resource. It also distinguishes from siblings by specifying 'Requires an ad_id (not account_id)' and pointing to get_ads for finding IDs, which differentiates it from tools like get_creative_details or get_ad_details.

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

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

It explicitly says 'Use get_ads first to find ad IDs', giving a clear workflow. It also clarifies the input constraint 'not account_id'. However, it does not mention alternative tools like get_creative_details when only a creative ID is available, but this is not a significant omission.

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?

No annotations are provided, so the description carries the burden. It discloses a useful behavioral detail: the access_token is optional and a cached token will be used if not provided. However, it does not mention other traits like error behavior, rate limits, or read-only nature, leaving some gaps.

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

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

The description is extremely concise: one clear sentence plus an args list. Every part adds value, and the structure is front-loaded with the main purpose. No waste.

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

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

Given the tool's simplicity (2 params, output schema present), the description is complete enough. It states purpose, parameters, and token behavior. The presence of an output schema means detailed return values are already defined, so the description need not explain them.

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

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

Schema description coverage is 0%, but the description compensates by explaining ad_id as 'Meta Ads ad ID' and access_token as 'Meta API access token (optional - will use cached token if not provided)', adding meaning beyond the schema's bare field titles.

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

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

The description clearly states the tool's function: 'Get detailed information about a specific ad.' It uses a specific verb and resource, and the singular 'specific ad' distinguishes it from sibling tools like get_ads (which likely lists ads).

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

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

The description implies usage: when you need details for a single ad. However, it does not explicitly mention when not to use it or recommend alternatives like get_ads for listing. The guidance 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns 'the image the ad is currently serving,' indicating the image may change over time, and mentions the optional access_token behavior ('will use cached token if not provided'). It implies a read-only operation and return format ('ready for direct visual analysis'). However, it doesn't explicitly state error handling or side effects, though for a get operation this is less critical.

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

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

The description is concise and well-structured. It starts with a clear summary sentence, then provides usage context, an alternative tool reference, and a structured Args/Returns section. No redundant information; every sentence adds value.

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

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

Despite having no output schema and no annotations, the description is complete for this simple tool. It explains the input parameters, the return behavior ('The ad image ready for direct visual analysis'), and provides contextual guidance on when to use an alternative tool. There are no significant gaps for the agent to make correct usage decisions.

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

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

Schema description coverage is 0%, so the description must compensate. It explains both parameters in the Args section: ad_id ('Meta Ads ad ID') and access_token ('Meta API access token (optional - will use cached token if not provided)'). This adds meaningful context beyond the bare schema, especially for the token behavior.

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

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

The description clearly identifies the tool's function: 'Get, download, and visualize the image attached to an existing Meta ad.' It uses a specific verb (get/download/visualize) and resource (existing Meta ad image). It also distinguishes itself from the sibling tool get_image_by_hash, explicitly stating 'If all you have is an image hash (no ad), use get_image_by_hash instead.'

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

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

The description provides explicit usage guidance, including when to use this tool (when you have a Meta ad ID) and when not to (when you only have an image hash). It names the alternative tool (get_image_by_hash), making the decision process clear for the agent.

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?

No annotations are provided, so the description must carry the full burden. It adds useful behavioral context: optional access_token falls back to cached token, limit defaults to 10, and filtering by campaign/adset is supported. However, it does not disclose pagination behavior, rate limits, or the exact scope of returned ads, leaving gaps.

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

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

The description is concise with a one-sentence purpose followed by an argument list. Each line is informative and earns its place, though the arg list could be seen as slightly redundant with the schema. Overall efficient and readable.

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

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

With an output schema present, return values need not be explained. The description covers purpose, all parameters, and some behavioral details (caching, defaults). It lacks explicit usage guidelines and deeper behavioral disclosure, but for a simple list tool it is reasonably complete.

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

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

Schema description coverage is 0%, and the description fully compensates by explaining every parameter: account_id format, access_token optionality with fallback, limit default, and campaign/adset filter purposes. This goes well beyond 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 clearly states 'Get ads for a Meta Ads account with optional filtering,' which identifies the verb (get), resource (ads), and scope (Meta Ads account). This distinguishes it from siblings like get_ad_details (specific ad) and get_campaigns (campaigns).

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

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

There is no guidance on when to use this tool versus alternatives such as get_ad_details or search_ads_archive. The description mentions optional filtering but does not explain when this listing tool is preferred over other ad-related 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?

No annotations are provided, so the description carries the burden. It states that access_token is optional and a cached token will be used if not provided, which is useful. However, it does not disclose return format, possible errors, or side effects, though the presence of an output schema mitigates this.

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

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

The description is concise, starting with a clear one-sentence purpose, followed by a structured Args block and a brief example. No wasted words, though the example is somewhat 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?

Given the tool's simplicity, the description covers the essential parameters and provides an example. The existence of an output schema covers return values. However, it lacks usage guidelines and prerequisites, making it minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains adset_id as 'Meta Ads ad set ID' and access_token as optional with cached fallback, adding meaning beyond the schema. However, it lacks format or source details for the ID.

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

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

The description clearly states the tool gets detailed information about a specific ad set, using a specific verb (get) and resource (ad set). It distinguishes from siblings like get_adsets (list) and get_ad_details (ad-level details).

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

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

The description implies use when you need details for a single ad set, but does not explicitly mention alternatives or exclusions. Sibling tool names like get_adsets suggest listing, but no direct guidance is provided.

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

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

Without annotations, the description provides some behavioral context by explaining the access_token caching behavior ('will use cached token if not provided') and the default limit. However, it does not discuss error behavior, pagination, or explicitly confirm it is a read-only operation.

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 compact docstring with a one-sentence purpose followed by a numbered Args list. Every line provides necessary information; there is no fluff or repetition.

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

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

The tool has 4 parameters and no schema descriptions, but the description covers all parameters and the core behavior. Missing pieces are usage guidance relative to sibling tools and explicit handling of edge cases or errors, though the output schema covers return values.

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

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

The input schema provides only titles and types with no descriptions, so the description is the sole source of parameter meaning. It explains the account_id format ('act_XXXXXXXXX'), the optional access_token with caching, the limit default (10), and the campaign_id filter, adding significant value beyond the schema.

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

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

The description opens with a clear statement: 'Get ad sets for a Meta Ads account with optional filtering by campaign.' This specifies the verb (Get), resource (ad sets), and scope (account, optional campaign filter), distinguishing it from sibling tools like get_campaigns or get_ads.

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

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

No guidance is given about when to use this tool versus get_adset_details (likely for a single ad set) or other sibling tools. The description does not mention exclusions or alternative scenarios, leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden. It discloses the processing status lifecycle ('processing' vs 'ready'), the error consequence for premature creative creation, and the rationale for using the advideos edge with account_id. This goes well beyond a simple read operation.

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 structured with a purpose statement, usage context, and parameter details. Every sentence adds value—the polling explanation, the account_id recommendation, and the Args list are all necessary. It is front-loaded with the core purpose and avoids redundancy.

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

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

The description is complete for a tool with an output schema. It covers the return values, the critical polling behavior, error scenarios, and parameter selection. The guidance on when to use versus when not to use create_ad_creative provides essential context 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%, and the description fully compensates by detailing each parameter in the Args section: ad_id extracts video, video_id for direct use, account_id enables edge lookup, and access_token defaults to cached token. This adds substantial meaning beyond raw schema types.

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

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

The description clearly states the tool's function: 'Get video details and source URL for a Meta ad video creative' and lists specific return values (video source URL, thumbnail URL, processing status, metadata). It distinguishes itself from siblings like get_ad_image and create_ad_creative by focusing on video retrieval and polling.

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

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

The description provides explicit when-to-use guidance: 'useful for polling after bulk_upload_ad_videos' and a clear when-not-to-use warning: 'Calling create_ad_creative before status is "ready" returns an error'. It also explains when to provide which ID and recommends account_id for avoiding specific errors.

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?

No annotations are provided, so the description carries the burden. It discloses that only a predefined set of fields is requested and that access_token is optional with a cached-token fallback. However, it doesn't mention error handling, rate limits, or what happens for invalid IDs. Some behavioral context is added, but it's not comprehensive.

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 structured with a clear main purpose, a useful note about field selection, and formatted argument explanations. Every sentence adds value, though the note could be seen as slightly tangential to basic usage. Overall efficient and well-organized.

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

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

Given it's a simple read operation with an output schema present, the description covers purpose, parameter semantics, and some behavioral nuances. It doesn't explain return values (covered by output schema) but lacks explicit guidance on when to use it vs alternatives. Good enough for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It clearly explains campaign_id as a Meta Ads campaign ID and access_token as optional with cached-token behavior. This adds meaningful context beyond the bare schema properties.

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 'Get detailed information about a specific campaign' clearly states the action and resource. It distinguishes from the sibling get_campaigns (which presumably lists campaigns) by focusing on a single campaign's details, though it doesn't explicitly mention when to use it over 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?

Usage is implied by the name and description ('a specific campaign'), but no explicit when-to-use or when-not-to-use guidance is provided. The note about requesting only a specific set of fields is more implementation detail than usage guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses that Meta API returns a subset of fields by default, that other fields may require explicit specification (not exposed), and explains how status_filter maps to effective_status. It also mentions token caching. This adds genuine behavioral context beyond the schema.

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

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

The description is well-structured with a clear opening sentence, a note about API field limitations, and an organized Args list. While somewhat long, every section adds value and the front-loading makes it scannable.

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

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

Given the tool's complexity (6 params, pagination, API quirks) and the presence of an output schema, the description covers the essential operational details. It explains filters, pagination, token handling, and field limitations. It omits error handling or permission requirements, but these are not critical for basic usage.

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

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

The schema has no parameter descriptions (0% coverage), but the description provides detailed explanations for all six parameters, including formats, defaults, valid values, mapping to API parameters, and pagination. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states 'Get campaigns for a Meta Ads account' which specifies the verb, resource, and scope. It also mentions optional filtering, which distinguishes it from siblings like get_campaign_details (singular detail) and create_campaign/update_campaign.

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

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

The description provides clear context for when to use the tool (retrieve campaigns for an account) and lists optional filters. It does not explicitly name alternatives or exclusions, but the context is strong enough for an agent to select it over sibling tools.

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

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

No annotations are provided, and the description does not disclose any behavioral aspects beyond the basic 'get' operation. It doesn't mention required permissions, potential errors, rate limits, or what fields are returned (though an output schema exists). The description adds little beyond what is obvious from the tool name.

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 succinct, front-loaded with the core purpose, and uses a well-structured Args list for parameters. Every sentence adds value; there is no fluff or redundancy.

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

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

Given the tool's simplicity (2 params, output schema present), the description adequately covers its purpose and parameters. It doesn't describe return values, but the output schema handles that. The only missing context is broader usage guidance, which is scored separately.

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

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

The schema has 0% coverage, but the description's Args section explains both parameters: creative_id as a Meta Ads creative ID (required) and access_token as an optional Meta API access token. This adds meaningful semantics beyond the bare type/title in the schema, though it doesn't elaborate on value formats or edge cases.

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

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

The description clearly states the tool gets detailed information about a specific ad creative by ID, using a specific verb and resource. It distinguishes from sibling tools like get_ad_creatives (which likely lists) and get_ad_details (which targets ads rather than creatives).

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

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

The description provides clear context: use when you have a specific creative ID and need its details. It doesn't explicitly exclude alternatives or mention when not to use it, but the 'by its ID' phrasing implies single-item retrieval rather than listing.

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

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

Annotations are absent, so the description carries full burden. It adds behavioral context like optional access_token with 'will use cached token if not provided' and implies read-only via 'get, download, visualize.' However, it does not explicitly state that it is read-only, nor does it disclose potential failure modes, rate limits, or required permissions. This is a moderate omission.

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 efficiently structured in three sections: purpose, usage guidance, and args/returns. Every sentence earns its place—there is no fluff, and the key information is front-loaded. The clear organization makes it easy for an agent to parse quickly.

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 tool with no annotations and no output schema, the description covers purpose, usage, parameters, and return value. The return statement 'The image ready for direct visual analysis' gives a general idea but could be more explicit about the format (e.g., URL, binary data). Still, given the tool's simplicity, this is near-complete.

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

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

The schema provides only titles and types, with 0% description coverage. The description's Args section compensates well: it explains the accepted formats for account_id ('act_XXXXXXXXX or bare numeric'), the purpose of image_hash, and the optionality of access_token with caching behavior. This adds meaningful semantics beyond the schema, though the image_hash description could be more detailed.

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

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

The description opens with a clear verb+resource: 'Get, download, and visualize a Meta ad image by its hash.' It also explicitly distinguishes from the sibling tool by stating 'To view the image of an existing ad, prefer get_ad_image(ad_id),' which removes ambiguity about when this tool is appropriate.

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 explicit usage context: 'Use this when you have an image_hash without an ad' and provides concrete examples of how such hashes arise. It also clearly states an alternative tool for a different scenario, satisfying both 'when to use' and 'when not to use' guidance.

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

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

With no annotations provided, the description fully carries the behavioral disclosure burden, and it excels. It reveals important behavioral quirks: auto-adding publisher_platform when platform_position is passed, auto-overriding action_breakdowns for media_type, unsupported breakdown fields that cause Meta errors, response size implications, and the compact mode behavior. This goes well beyond minimal disclosure.

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

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

The description is long and detailed, but every sentence contributes useful information for correct usage. It is well-structured with an Args section and note blocks, and it front-loads the main purpose. It loses one point for verbosity—the breakdown list could be trimmed or moved to schema enums—but overall, it is appropriately sized for a 14-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?

The description is exceptionally complete for the tool's complexity. It covers all 14 parameters, enumerates valid breakdown values, explains restrictions, describes response size behavior, and provides an alternative tool. Even with an output schema present, the description adds critical context about return fields and aggregates, making it self-sufficient for an agent to invoke correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does so comprehensively: each parameter is explained with its purpose, accepted values, presets, aliases, and special rules (e.g., time_range presets, breakdown valid values, pagination cursor). The description adds extensive meaning beyond the schema's bare titles and defaults.

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

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

The description opens with 'Get performance insights for a campaign, ad set, ad or account,' which combines a specific verb, resource scope, and clear output type. This immediately distinguishes it from sibling tools like get_campaign_details or get_ads, which focus on configuration details rather than performance metrics.

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

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

The description explicitly says 'If you only need specific metrics like spend or impressions, consider using bulk_get_insights with compact=true and the fields parameter,' naming the alternative and the conditions under which it should be used. It also notes that this tool always returns a fixed set of fields, implying when not to use it. This satisfies the when-to-use vs. alternatives requirement.

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 no annotations, the description carries the behavioral transparency burden. It discloses useful traits: access_token is optional and a cached token is used if not provided, and the return is a JSON string with specific fields. This goes beyond the basic 'get' semantics.

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

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

The description is well-structured with a clear opening sentence, followed by a concise Args section and a Returns line. Every line earns its place, with no redundant or verbose content.

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

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

The description covers all core aspects: purpose, parameters, token handling, and return format. It does not mention error cases or network calls, but for a straightforward suggestion tool with an output schema, it is sufficiently 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 must fully explain parameters. It does so effectively: interest_list with an example, access_token with caching note, and limit with default value. This adds significant meaning beyond the schema's raw type definitions.

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

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

The description clearly states the tool's purpose: 'Get interest suggestions based on existing interests.' This specifies a verb ('get') and resource ('interest suggestions') and distinguishes it from sibling tools like search_interests by emphasizing the suggestion generation from existing interests.

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 usage is implied from the description: provide an interest_list to receive related suggestions. However, there is no explicit guidance on when to use this tool versus alternatives like search_interests or estimate_audience_size, and no exclusions 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?

Tool has no description.

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

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

Tool has no description.

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?

Tool has no description.

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?

Tool has no 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?

Tool has no description.

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?

Tool has no description.

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?

No annotations are provided, so the description carries the full behavioral burden. It hints at the return content (definition + formula) but discloses nothing about permissions, valid metric identifiers, or failure behavior. For a read-only lookup this is low-risk, but no behavioral context is added.

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. It communicates the action and the returned artifact compactly.

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

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

An output schema exists, so return-value detail is not required, and the tool has only one simple parameter. However, for a definition-lookup tool the description never tells the agent what metric identifiers are valid or when to reach for it over calculating tools, leaving a real gap.

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

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

Schema description coverage is 0%, so the description must compensate for the single 'metric' parameter. It only implies the parameter is a growth metric name; it gives no format, no valid-value examples, and no indication of what identifiers are accepted.

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: 'Return a concise definition and calculation formula for a growth metric.' An agent can tell this is a lookup/reference tool, distinct from calculation siblings like calculate_growth_metrics or compare_campaign_metrics. It stops short of explicitly naming any sibling for 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?

There is no when-to-use guidance, no prerequisites, and no mention of how this differs from the many sibling metrics tools. The agent must infer that this is for looking up a definition rather than computing values.

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 no annotations provided, the description carries the full behavioral burden. "Auditable" hints that output is meant to be evidence-grade, but nothing is said about whether the tool is read-only or writes anything, how it handles the supplied records, or any limits/determinism concerns.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though the terseness is arguably under-specification rather than disciplined concision for a 3-parameter tool.

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

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

An output schema exists, so return values need not be explained, but with no annotations, 0% parameter coverage, and no routing guidance relative to near-identical siblings, an agent lacks the information needed to call this confidently.

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

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

Schema description coverage is 0% and the description never mentions campaign_name, records, or compare_period_records. It gives no clue what shape "records" should take or how the optional comparison period changes results, so an agent cannot construct a correct call from the description alone.

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

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

The description names a verb ("Build") and a product ("auditable campaign investigation packet") with a hint of contents ("metrics, drivers, and evidence"). It does not, however, distinguish this from the sibling build_evidence_packet, which sounds like the same artifact, so the purpose remains fuzzy at the level an agent needs.

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 build_evidence_packet, investigate_growth_issue, compare_campaign_metrics, or analyze_growth_query, and no mention of prerequisites or expected input conditions. The agent is left to guess from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does not say whether the tool is read-only, what it does with the supplied record sets, whether previous_records is needed for comparison, or any cost/rate characteristics. 'Auditable dimensional evidence' gestures at output but adds no actionable 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?

A single front-loaded sentence with no filler or repetition. It is efficient, though the 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?

An output schema exists, so return values need not be explained, but for a 4-parameter analytical tool with zero schema coverage and no annotations the description omits too much: it never indicates the required question/current_records pairing or how previous_records and user_events change the analysis. An agent could not assemble a correct call from this text 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% across 4 parameters, and the description supplies no meaning for question, current_records, previous_records, or user_events. Parameter names are somewhat self-explanatory, which keeps this above 1, but nothing explains expected record shapes or the role of the optional event/previous-record inputs.

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

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

The description names a specific verb and resource ('Investigate a growth-metric change') and hints at method ('formula drivers', 'auditable dimensional evidence'). However, it does nothing to separate this tool from close siblings such as analyze_growth_query, detect_metric_anomalies, or calculate_growth_metrics, so an agent cannot confidently pick it from the name 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 statement of when to use this tool versus the many overlapping growth/analysis siblings, no prerequisites (e.g., that records must be supplied), and no exclusions. The single sentence describes output flavor rather than invocation context.

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

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

With no annotations, the description carries the entire behavioral burden, and it discloses nothing about whether the operation is read-only or mutating, whether original records are modified, how unknown source types are handled, or whether unrecognized fields are dropped or preserved.

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

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

It is a single front-loaded sentence with zero filler, so it reads cleanly; the only reservation is that such brevity leaves no room for the behavioral detail an unannotated tool needs.

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

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

An output schema exists, so return values need not be explained, but for a tool with two fully undocumented parameters and no annotations the description omits the input-format expectations and normalization-selection semantics that an agent needs to invoke it correctly.

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

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

Schema description coverage is 0% for both parameters. The description implies what "records" holds but never states the accepted input shapes, required keys, or what "source" (defaulting to "unknown") changes in the normalization behavior.

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

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

The description gives a specific verb ("Normalize"), a clear input class ("heterogeneous marketing records"), and a named target ("the canonical GrowthMCP schema"), which is enough for an agent to distinguish it from the CRUD/analytics siblings in the toolset.

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 reach for this tool versus alternatives, no preconditions, and no mention of what upstream step should produce the records being normalized. Usage is only faintly implied by the word "heterogeneous".

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 no annotations, the description carries the transparency burden. It does disclose that access_token is optional and falls back to a cached token, and the curl example reveals it's a GET request, but it omits pagination, rate limits, and error handling.

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

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

The description is well-organized with a concise purpose statement, an Args list, and a practical example. It is slightly long, but each section serves a clear function.

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

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

For a search tool with an output schema, this description covers the core purpose, all parameters, and usage context. It lacks explicit guidance on pagination and alternative tools, but is otherwise complete.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining every parameter in the Args section and providing a concrete curl example. It adds meaning beyond the schema by clarifying optionality and example values.

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

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

The description uses a specific verb 'Search' and names the resource 'Facebook Ads Library archive', clearly defining the tool's functionality. This resource scoping distinguishes it from sibling search tools like search_pages_by_name or search_interests.

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 through a curl example, but it never explicitly states when to use this tool over alternatives like search_pages_by_name or search_interests. No exclusion or alternative guidance is provided.

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

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

No annotations exist, so the description carries the transparency burden. It discloses that access_token is optional and a cached token is used if not provided, and it describes the return format (JSON string with id, name, audience_size bounds, etc.). This adds meaningful context beyond the schema, though it does not mention rate limits or max limit constraints.

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

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

The description is concise and well-structured with separate Args and Returns sections. Every sentence provides useful information without redundancy, making it easy to scan.

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

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

Given the tool's simplicity, the description covers the purpose, parameters, and return format effectively. It is self-contained and sufficient for an agent to invoke correctly, even without an output schema (which is present anyway).

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

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

The description explicitly explains both parameters: access_token (Meta API token, optional) and limit (maximum results, default 50). This adds meaning beyond the schema's types and defaults, compensating for the 0% schema description 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 uses a specific verb ('Get') and resource ('behavior targeting options'), clearly distinguishing it from sibling tools like search_interests or search_demographics. The scope is well-defined and immediately understandable.

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 for retrieving behavior targeting options but does not explicitly state when to use it versus alternatives such as search_interests or search_demographics. No exclusions or alternative tool references are provided.

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

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

The description discloses that access_token is optional and falls back to a cached token, lists all accepted demographic_class values, and explains the return JSON format with specific fields. Since no annotations are provided, the description carries the full burden and does so effectively, though it omits details like rate limits or error 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 a one-sentence purpose, then follows a clear Args/Returns structure. Every line serves a purpose, with no redundant 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?

With no annotations and a relatively simple read-only tool, the description covers purpose, parameters, defaults, allowed values, and return format. This is fully sufficient for an agent to select and invoke the tool correctly, especially given the 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?

The input schema has 0% description coverage, so the description provides essential meaning for all three parameters: access_token behavior, demographic_class allowed values with default, and limit default. This goes well beyond 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 clearly states it retrieves demographic targeting options, with a specific verb and resource. The list of demographic_class values (e.g., 'life_events', 'income') differentiates it from sibling search tools like search_interests and search_behaviors.

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 through the demographic_class parameter and the tool's name, but the description does not explicitly state when to use this tool versus alternatives like search_interests or search_geo_locations. There are no direct comparisons or exclusions.

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

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

With no annotations provided, the description carries the full burden and discloses important behaviors: access_token is optional with cached fallback, location_types defaults to all, limit defaults to 25, and the return format is a JSON string. However, it does not mention rate limits, permissions, or error handling, so it's not fully transparent.

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 structured with Args and Returns, leading with a clear purpose sentence. It is somewhat list-heavy but appropriately sized given the need to document four parameters with no schema descriptions. No wasted words.

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

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

The description covers all parameters, defaults, and return format. With an output schema present, it does not need to fully explain return fields, but it does mention key fields. It lacks pagination or no-result behavior, but for a search tool this is acceptable.

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 fully compensates by explaining every parameter: query with examples, access_token behavior, location_types options, and limit default. This adds substantial meaning beyond the bare schema titles.

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

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

The description clearly states 'Search for geographic targeting locations,' which is a specific verb + resource. It distinguishes this from sibling tools like search_interests and search_behaviors by explicitly focusing on geographic locations.

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 its use for geographic targeting but does not explicitly state when to use it over alternatives like search_interests or search_behaviors. No exclusions or alternative tool references are provided.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds value by specifying the return format as a JSON string with fields (id, name, audience_size, path) and by disclosing that access_token is optional and will use a cached token if not provided. This goes beyond the schema's basic parameter types.

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 tightly structured with a one-sentence purpose followed by a concise Args/Returns list. Every line serves a clear informational purpose 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?

The tool definition covers purpose, all parameters, and return format. While it lacks explicit error handling or limitations, the presence of an output schema and the detailed parameter/return descriptions make it sufficiently complete for a straightforward search operation.

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 the input schema having 0% description coverage, the tool description fully compensates by explaining all three parameters: query with concrete examples, access_token with caching behavior, and limit with its default value. This provides semantic meaning well beyond the schema.

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

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

The description uses a specific verb 'Search' and clearly identifies the resource as 'interest targeting options'. This distinguishes it from sibling tools like search_behaviors and search_demographics, which target different entity types.

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

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

The description implies usage by defining the tool as a keyword search for interests, but it does not explicitly state when to use it over alternatives like search_behaviors or get_interest_suggestions, nor does it provide any exclusionary guidance.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses two important behavioral traits: access_token is optional and falls back to a cached token, and search_term is optional and returns all pages when omitted. It also specifies the return type as JSON. This goes beyond basic schema info, though it doesn't cover pagination or error 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 concise and well-structured: a single purpose sentence followed by an Args section and a Returns line. No wasted words. The most important information is front-loaded.

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

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

For a simple 3-parameter tool with an output schema, the description covers the essential context: what the tool does, parameter meanings, and return type. It omits potential pagination or rate-limit details, but given the tool's simplicity and the presence of an output schema, it is sufficiently complete.

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

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

The schema has no descriptions for its parameters (0% coverage). The description compensates fully with an Args section that explains each parameter: account_id format, access_token optionality with cached token behavior, and search_term optionality with 'return all pages' behavior. This adds significant meaning beyond 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 clearly states the tool's function: 'Search for pages by name within an account.' It specifies the resource (pages), the action (search), and the scope (by name within an account). While it doesn't explicitly compare to sibling tools like get_account_pages, the 'by name' qualifier implies a distinction from listing all pages.

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: use this tool when you need to find pages by name. It does not explicitly state when _not_ to use it or mention alternatives, but the purpose sentence is enough to infer when it is appropriate. No exclusions or alternatives are provided.

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

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

No annotations are provided, so the description must disclose behavior. It does add useful context: access_token is optional and 'will use cached token if not provided,' and creative_id 'changes the ad's image/content.' However, it does not disclose whether unspecified fields are reset, rate limits, or other side effects, leaving some ambiguity for 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?

The description is efficiently structured with a purpose line followed by a compact Args list. Each parameter gets a single line with no wasted words, making it easy to parse.

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

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

Given the tool has 7 parameters and no annotations, the description covers all parameters and includes some behavioral notes. The presence of an output schema reduces the need to describe return values. However, it lacks discussion of partial vs. full update behavior or error conditions, which is a notable gap for a mutation tool.

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

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

Schema coverage is 0%, so the description fully compensates by explaining every parameter. It adds crucial semantics like bid_amount being 'in cents for USD' and tracking_specs being 'optional tracking specifications (e.g., for pixel events).' This provides meaning beyond 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 opens with 'Update an ad with new settings', a specific verb+resource that clearly identifies the tool's function. It distinguishes from sibling tools like update_campaign and update_adset by focusing on '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?

The description provides no guidance on when to use this tool versus alternatives like create_ad or update_ad_creative. It does not mention any exclusions or prerequisites, leaving the agent to infer usage from the name alone.

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

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

With no annotations provided, the description carries full transparency burden. It discloses the key limitation that content fields will likely be rejected, notes the reliability of the name field, explains the access_token fallback behavior, and provides field-specific caveats. It also clarifies how creative_features_spec should be sent (top-level field).

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 longer than ideal, with the 'NOTE: Meta API may reject this' repeated for six separate fields. However, it is well-structured with an Args list and Returns section, and the length is justified by the need to document 15 parameters and a critical API constraint. Every section earns its place, though some repetition could be consolidated.

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

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

Given the tool's complexity (15 params, no annotations, presence of output schema), the description is complete. It covers purpose, usage boundaries, parameter semantics, and expected returns. It also references the related update_ad tool, providing necessary cross-tool context. The output schema handles return details, so the brief Returns line is sufficient.

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

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

Schema description coverage is 0%, but the description documents all 15 parameters, including type guidance (e.g., 'DEGREES_OF_FREEDOM' for flex creatives, ['AUTOMATIC_FORMAT'] for flexible ads) and explicit notes on which will likely be rejected. This fully compensates for the missing schema descriptions.

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

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

The description clearly states the tool 'Update an existing ad creative's name or optimization settings' and explicitly contrasts with content updates. It names the resource (ad creative) and the specific allowed changes, distinguishing it from siblings like create_ad_creative and update_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?

The description explicitly explains when to use this tool (for name/optimization settings) and when not to (for content fields), and it names the alternative workflow: create a new creative and reference it via update_ad. The 'IMPORTANT — Meta API limitation' note provides clear guidance.

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

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

With no annotations provided, the description carries the full burden and excels. It discloses critical behavioral traits: silent ignore for is_dynamic_creative ('Meta's API will return success but silently ignore the change'), API rejection for attribution_spec ('will be rejected by Meta's API'), invalid bid_strategy values, allowlisting requirement for bid_adjustments, token caching, and that targeting 'replaces existing targeting.' These are genuine behavioral disclosures beyond mere parameter definitions.

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

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

The description is long but appropriately so for a 22-parameter tool. It follows a clean Args list structure with a one-line summary at the top. Each parameter description is terse and information-dense; warnings are italicized and clearly marked. While some might argue it is verbose, every sentence adds value and there is minimal redundancy.

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

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

For an update operation with 22 optional parameters and no annotations, the description is exceptionally complete. It covers all parameters, including niche ones like DSA compliance, regional regulated categories, and multi_advertiser_ads. It notes dependencies, warns about immutable fields, references create_adset for shared documentation, and an output schema exists so return values need not be described. The description equips an agent to make correct calls with confidence.

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

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

Schema description coverage is 0%, so the description must compensate fully—and it does. It provides concrete examples (frequency_control_specs, bid_constraints), unit clarifications (currency in cents, ISO 8601 format), valid values for bid_strategy, cross-field dependencies (bid_amount required for certain strategies, end_time required with lifetime_budget), and instructions for clearing fields (set to null). This vastly enriches 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 clearly states 'Update an ad set with new settings including frequency caps and budgets.' The verb 'Update' identifies a mutation operation on a specific resource, and the mention of frequency caps and budgets adds specificity. It distinguishes from sibling tools like create_adset and get_adsets by focusing on modifying an existing entity.

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

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

The description provides explicit when-not-to-use guidance for certain fields: it warns that is_dynamic_creative is immutable after creation and directs, 'To change this, create a new ad set,' and for attribution_spec it similarly advises creating a new ad set instead. However, it lacks a general statement like 'Use this to modify an existing ad set; for creation use create_adset,' so it does not fully earn 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?

With no annotations, the description carries full burden for behavioral disclosure. It reveals that Meta silently ignores empty daily_budget/lifetime_budget for the deprecated flag, that adset_budgets performs an atomic migration, and that objective may not always be updatable. This goes well beyond a bare 'update' statement.

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

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

The description is well-structured with a main statement, a note, a migration section, and an Args list. It is slightly long, but the length is justified by the 14 parameters and the complex migration behavior. Every section serves a purpose.

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

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

Given the tool's complexity (14 params, no annotations, no schema descriptions), the description covers all critical aspects: parameter semantics, migration mechanism, deprecated flag behavior, and a caveat about start_time. The presence of an output schema handles return values, so the description is complete for an agent to select and invoke the tool.

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

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

Schema coverage is 0%, so the description must fully explain parameters. It does so thoroughly: each param has a clear meaning, units (cents), optionality, and examples for adset_budgets. It also flags deprecation for use_adset_level_budgets and explains the recommended alternative.

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

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

The description opens with 'Update an existing campaign in a Meta Ads account', a clear verb+resource statement. It implicitly distinguishes from create_campaign and update_adset by specifying the target object (campaign) and the action (update).

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

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

The description provides explicit guidance on when to use adset_budgets instead of the deprecated use_adset_level_budgets for CBO→ABO migration, and notes that start_time should be set on the ad set rather than the campaign. It clearly implies this tool is for updating existing campaigns, though it doesn't explicitly contrast with create_campaign or update_adset.

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 no annotations provided, the description carries the burden of behavioral disclosure. It explains that access_token is optional due to a cached token, describes the return format (image_hash and images list with CDN URL), and states that the URL can be fetched directly. It omits permissions, error conditions, or rate limits, but covers the key operational aspects beyond the tool's name.

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

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

The description is well-structured with a one-sentence purpose, an Args list, and a Returns list. Every sentence provides essential information—no filler or redundancy. The length is appropriate for the number of parameters and return fields.

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

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

The description is fully self-sufficient: it explains all parameters, return values, and how to use the result (e.g., with create_ad_creative or get_image_by_hash). The output schema is already present, and the description adds the necessary context for an agent to invoke the tool correctly and interpret the response.

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 description coverage is 0%, and the description fully compensates by documenting every parameter in the Args section. It provides format examples (e.g., 'data:image/png;base64,...'), clarifies the relationship between file and image_url, and notes defaults for name. This goes well beyond the schema's bare property definitions.

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 'Upload an image to use in Meta Ads creatives' with a specific verb, resource, and intended purpose. It clearly distinguishes itself from sibling tools like upload_ad_video by focusing on images and their use in ad creatives.

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

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

The description gives clear context: it explains what to do with the returned image_hash ('Pass this to create_ad_creative...') and notes that the CDN URL can be fetched directly, eliminating the need for immediate follow-up calls. It does not explicitly name alternatives or exclusion scenarios, but the context effectively conveys when and how to use the tool.

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