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, the description carries the full burden. It discloses error codes and subcodes (error_subcode=1487390, error 1885800, error 1443048), automatic routing behavior (video_id + instagram_actor_id always routes through asset_feed_spec), silent serving behavior (DOF collapses multiple image_hashes to one image), and thumbnail processing states. It also notes the 'Returns: JSON response with created creative details' line. This is far beyond basic 'create' 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 extremely long and includes some redundancy (asset_customization_rules appears in two places). It is well-structured with markdown headers and examples, and it is front-loaded with the core purpose. However, it could be tightened; not every sentence is essential, and the length may hinder quick parsing.

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 36 parameters and six distinct modes, the description is remarkably complete. It covers error handling, defaults (e.g., ad_formats default to ['SINGLE_IMAGE']), prerequisites (e.g., upload video first), and cross-field dependencies (e.g., link_url required for Lead ads when asset_customization_rules set). The only minor omission is page_welcome_message, and the output schema would handle return-value documentation.

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

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

Schema description coverage is 0%, so the description must compensate. It does so thoroughly: each parameter is explained with formats, constraints, examples, and cross-field compatibility. For instance, object_story_id format '{page_id}_{post_id}', image_crops valid keys with aspect ratios, phone_number E.164 format, and the note that messages can be plain string or dict with adlabels. It covers 35 of 36 parameters, omitting only page_welcome_message from 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 verb+resource statement: 'Create a new ad creative using an uploaded image hash, video ID, or an existing post.' It then enumerates six creative modes, distinguishing it from siblings like create_carousel_ad_creative and update_ad_creative. This is specific and non-tautological.

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 extensive when-to-use guidance for each of the six modes (e.g., 'Simple image/video: Single image_hash or video_id with object_story_spec') and explicit parameter constraints like 'cannot be used with image_hashes or video_id'. It also gives practical workarounds (e.g., 'wait a few seconds ... and retry'). However, it does not explicitly name sibling tools as alternatives (e.g., 'use create_carousel_ad_creative for carousels'), so it falls short of a perfect 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 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?

With no annotations, the description carries the full burden for behavioral disclosure. It explains the creation and return value (creative_id or Meta error), and documents defaults for multi_share_end_card and multi_share_optimized. However, it omits any mention of permission requirements, access_token handling, or the irreversible/persistent nature of the write operation beyond implied creation. This is a notable gap 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 well-organized with 'Args' and 'Returns' sections, front-loads the tool's purpose, and uses a compact code block for the nested child_attachments. Every line adds value, and the length is appropriate for the complexity. 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?

The tool is complex with nested structures and multiple optional parameters, and the description covers most of it, including return integration with create_ad and reference to upload_ad_image for image_hash. Missing access_token explanation and lack of error detail prevent a 5, but the description is largely sufficient 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 compensate. It provides detailed, meaningful explanations for 9 of 10 parameters, including a full breakdown of child_attachments structure with examples. Only access_token is not discussed, but the description still far exceeds baseline by adding operational meaning that the schema entirely lacks.

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 'Crea un ad creative tipo CARRUSEL (2-10 tarjetas deslizables)', clearly specifying a carousel ad creative with a range of cards. This differentiates it from sibling tools like create_ad_creative, which is likely for single-format creatives. The verb 'Crea' and resource 'ad creative' are explicit.

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 is for carousel ads with 2-10 cards, and explicitly instructs to use the returned creative_id 'luego en create_ad'. It does not contrast with alternative tools like create_ad_creative, but the name and scope make the intended use obvious. No exclusions or when-not conditions 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?

With no annotations, the description carries the full behavioral disclosure burden. It discloses important traits: admin requirement, immediate vs. hidden publishing, and return format. It stops short of covering edge cases like conflicting parameters or idempotency, but it is substantially informative.

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 labeled sections (Modes, Args, Requires, Returns). Every sentence adds value, and there is no fluff or repetition. It is concise yet complete for 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?

Given the tool's complexity (6 params, no annotations) and the presence of an output schema, the description covers key behavioral aspects: modes, auth requirements, publishing behavior, and return value. It is sufficiently complete for an AI 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 compensates by explaining message, link, image_url, published, and access_token, including their roles across modes. It does not explicitly describe page_id, but the opening sentence implies its meaning. Overall, strong parameter guidance for a 0%-coverage 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 with a specific verb and resource: 'Crea una publicación ORGÁNICA en la Página de Facebook'. It explicitly distinguishes from paid advertising ('NO es un anuncio pago'), which differentiates it from sibling ad-creation tools.

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

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

The description provides context on when to use the tool and when not to (not for paid ads), and explains that published=False creates a dark post for later promotion. However, it does not explicitly name alternative sibling tools, so it falls short of the highest bar for usage guidelines.

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. It explains key behaviors: deep_copy affects ad sets/ads, status_option controls the copy's state with PAUSED recommended, and the return JSON includes the new campaign ID. It doesn't discuss authentication or permissions, but the core behavioral aspects are disclosed.

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, uses concise Spanish, and front-loads the purpose. Every sentence adds value; no filler 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?

The description covers purpose, parameter semantics, and return format adequately for a 5-parameter tool. It lacks any mention of access_token and does not elaborate on error conditions beyond 'el error de Meta', but overall it provides enough context for an agent to invoke the tool correctly.

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

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

Schema coverage is 0%, so the description must compensate. It adds meaningful explanations for campaign_id, deep_copy, status_option, and rename_suffix, including defaults and examples. However, it omits access_token entirely, leaving one parameter 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?

The description clearly states it duplicates an existing campaign via the Meta /copies endpoint, and positions it as ideal for horizontal scaling. This specific verb+resource combination distinguishes it from siblings like create_campaign and 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?

Provides a clear use case ('Ideal para escalamiento horizontal (clonar una campaña que ya funciona)'), implying when to use it. However, it does not explicitly mention alternatives or when not to use it, so it lacks the full 'when/when-not' guidance of a top-tier score.

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 provided, the description fully bears the burden of behavioral disclosure. It clearly states that the tool does NOT make direct API calls to Meta, only returns records cached by 'search', and returns 'Record not found' if the record was not previously cached. This is transparent about its limitations and expected 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 well-structured and front-loaded, with the main purpose in the first sentence. It uses clear sections for limitations, alternative tools, arguments, and return value. Every sentence adds necessary value, and the length is appropriate for the complexity of the tool's behavior.

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

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

Given that this is a simple tool with one parameter and no annotations, the description covers all essential context: what it does, its limitations, when to use alternatives, the parameter format, and the return value. It also works well with the existing output schema, making the tool self-explanatory.

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

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

The input schema only defines 'id' as a string with no description. The description compensates fully by explaining the exact format ('type:id', e.g., 'account:act_123456') and the requirement that it must have been returned by a previous 'search' call. This adds significant meaning beyond the schema.

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

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

The description clearly states that the tool fetches a record previously returned by the 'search' tool in the same session, using a specific verb+resource+scope. It distinguishes itself from sibling lookup tools by explicitly noting it does NOT make direct API calls and only works on cached records.

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 and when-not-to-use guidance, including a list of alternative tools for direct lookups by ID (e.g., get_campaign_details, get_adset_details, get_ads, get_adsets). It also explains the critical prerequisite that the record must have been returned by a prior 'search' call.

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?

Since no annotations are provided, the description carries the burden. It discloses that the access_token is optional and that a cached token will be used if omitted, which is a meaningful behavioral detail beyond what annotations would provide. For a simple auth-link tool, this is sufficient, though it doesn't explicitly confirm non-mutating 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 succinct: a one-sentence purpose, a short note with usage guidance, and a compact Args block. It avoids redundancies, and 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?

Given the tool's simplicity, the description covers purpose, usage context, parameter behavior, and return type. An output schema exists, so detailed return fields are not required. Everything an agent needs to select and invoke this tool correctly is present.

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

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

The schema provides no parameter descriptions (0% coverage), but the description compensates with an Args section explaining the access_token parameter's purpose ('Meta API access token') and its optionality ('will use cached token if not provided'). This adds clear value 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 clearly states the tool's function with a specific verb ('Get') and resource ('clickable login link for Meta Ads authentication'). It is distinct from all sibling tools focused on pages, campaigns, and ads. The purpose is immediately obvious.

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

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

Explicitly provides when to use this tool (when using your own Facebook app) and when not to use it (when using Pipeboard authentication, instead set the PIPEBOARD_API_TOKEN). It also names the alternative approach, making the guidance highly actionable.

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 of behavioral disclosure. It does disclose that only organic posts are returned and enumerates the post fields and metrics. However, it does not mention authentication requirements (despite an access_token parameter), rate limits, or pagination, leaving some behavioral ambiguity for a 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 concise, front-loaded with the main purpose, and well-structured using Args/Returns blocks. Every sentence contributes meaningful information without repetition 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?

For a list-style tool with a modest parameter set and an output schema present, the description covers the essentials: purpose, key arguments, and return value structure. The main gap is access_token semantics and lack of pagination details, but overall it is sufficient for most use cases.

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 page_id and limit clearly ('ID de la Página', 'Máximo de publicaciones a devolver (default 25)'), adding meaning beyond the bare schema. However, it omits the access_token parameter entirely, leaving one parameter undocumented in both schema and description.

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

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

The description begins with a specific verb and resource: 'Lista las publicaciones ORGÁNICAS de la Página' (lists the page's organic posts), and further details the included metrics and insights. This clearly distinguishes it from sibling tools like get_insights, which likely aggregates page-level insights, and create_page_post, which creates posts.

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 clearly implies the tool is for retrieving a page's organic posts with interaction and insight metrics. However, it does not explicitly state when to use this over alternatives (e.g., get_insights for aggregated insights) or mention exclusions like paid posts or pagination behavior.

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 carries the full burden. It does disclose the optional access_token behavior (cached token fallback) and the return format (JSON with matching record IDs). However, it does not mention that the search is read-only, nor does it clarify matching semantics (exact, partial, fuzzy) or potential rate limits/pagination, leaving behavioral 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 well-structured with Args, Returns, and Example Usage sections. It is not overly long, though the five example usage lines are somewhat redundant. The key information is front-loaded in the first two sentences, and 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?

For a search tool with two parameters and an output schema, the description provides a decent overview. It states the return format (list of matching record IDs) and supports examples. However, it lacks details on result limits, pagination, or how search results are ranked/ordered, which are common concerns for search tools. The existence of an output schema reduces the need to explain return values, but behavioral aspects like result boundaries remain uncovered.

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

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

The input schema only provides types, with 0% description coverage. The description compensates by explaining 'query' as a search query string to find relevant records and 'access_token' as an optional token with cached fallback. This adds meaningful context beyond the schema, though it could be more detailed about query syntax or accepted 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 clearly states 'Search through Meta Ads data and return matching record IDs' with a specific verb and resource. It further specifies the scope by listing ad accounts, campaigns, ads, pages, and businesses, distinguishing it from the more specific sibling search tools like search_pages_by_name or search_ads_archive.

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 context is implied through examples like 'search(query="active campaigns")' and 'search(query="user businesses")', which show cross-entity searching. However, there is no explicit guidance on when to use this generic search versus the dedicated sibling search tools, nor any exclusions for when it is not appropriate.

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

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

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.