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 the default PAUSED status, optional access_token with a cached fallback, and the dynamic-creative constraint with a specific error subcode. These are useful behavioral details, though it does not mention permissions or rate limits.

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

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

The description is well-structured: a front-loaded one-sentence summary, a parameter list with helpful details, and a critical note. Each line earns its place, and the tracking_specs example is valuable despite adding length.

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 Meta Ads API create operation with 8 parameters, the description covers all parameter semantics, the default behavior, and a known failure mode. It is sufficiently complete given an output schema exists. A minor gap is the lack of accepted status values and account/adset consistency constraints, but these are not essential for basic invocation.

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

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

The schema has no property descriptions (0% coverage), but the description compensates by explaining every parameter, including the act_ format for account_id, bid_amount in cents, a tracking_specs JSON example, and the optional cached access token. 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 opens with 'Create a new ad with an existing creative,' clearly stating the action (create), the resource (ad), and a key constraint (existing creative). This distinguishes it from sibling tools like create_ad_creative or 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 phrase 'with an existing creative' gives clear context that a pre-existing creative ID is required, implying that creative creation should happen first via a different tool. The dynamic creative note also provides a specific prerequisite. However, it does not explicitly name alternative tools or say 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 provided, the description carries the full burden of behavioral disclosure. It indicates this is a creation/mutation operation and mentions some constraints (e.g., parameter exclusivity rules), but doesn't cover important behavioral aspects like authentication requirements beyond the optional access_token, rate limits, error handling, or what happens when creation fails. It provides basic operational context but lacks comprehensive 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 well-structured with clear sections (Args, Returns) and uses bullet-like formatting for parameters. While comprehensive for 15 parameters, every sentence serves a purpose - no redundant information. The opening purpose statement is front-loaded, followed by organized parameter documentation.

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 (15 parameters, creation operation) and absence of annotations, the description does substantial work. It documents all parameters thoroughly and mentions the return format. With an output schema present, it doesn't need to detail return values. The main gap is lack of behavioral context (auth, errors, limits) which prevents a perfect score.

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

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

With 0% schema description coverage for 15 parameters, the description provides extensive parameter documentation that fully compensates for the schema gap. It explains each parameter's purpose, format requirements (e.g., 'format: act_XXXXXXXXX'), constraints (e.g., exclusivity rules between headline/headlines), and contextual relationships (e.g., lead_gen_form_id requirements for specific CTAs). This adds significant value 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 specific action ('Create a new ad creative') and resource ('using an uploaded image hash'), distinguishing it from siblings like 'create_ad' or 'update_ad_creative'. The opening sentence provides a complete purpose statement that goes beyond just restating the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'create_ad' or 'update_ad_creative'. While it mentions some parameter constraints (e.g., 'cannot be used with headlines'), it doesn't offer contextual guidance about appropriate use cases, prerequisites, or tool selection criteria.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation tool (implying mutation) but doesn't mention required permissions, rate limits, error conditions, or what happens on success/failure. Some parameter descriptions hint at behavior (e.g., 'for European compliance'), but overall behavioral context is minimal for a complex creation tool with 18 parameters.

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

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

The description is appropriately front-loaded with the purpose statement, followed by detailed parameter documentation. However, it's quite lengthy (18 parameter explanations) which is necessary given the complexity but reduces conciseness. Some parameter explanations could be more succinct (e.g., the promoted_object example is quite detailed).

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 (18 parameters, creation operation, no annotations) and the existence of an output schema, the description provides substantial context. It thoroughly documents parameters and their semantics. The main gaps are behavioral aspects (permissions, errors) and usage guidelines versus siblings. With output schema handling return values, this is reasonably complete for the creation context.

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

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

With 0% schema description coverage, the description provides extensive parameter semantics that fully compensate. It explains 18 parameters with format examples, constraints, dependencies, and usage notes (e.g., 'in cents as a string', 'Required for mobile app campaigns', 'Use targeting_automation.advantage_audience=1'). This adds significant value 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 'Create a new ad set in a Meta Ads account' - a specific verb ('Create') and resource ('ad set') with platform context. It doesn't explicitly differentiate from sibling tools like 'create_campaign' or 'create_ad', but the resource specificity is clear. Not a tautology as it provides meaningful action and context.

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_campaign' or 'update_adset'. It mentions some parameter dependencies (e.g., 'Required for mobile app campaigns') but doesn't offer broader usage context, prerequisites, or comparisons to sibling tools. The agent must infer usage from parameter descriptions 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 the full burden. It discloses the return format ('JSON string containing the ID... or an error message'), the meaning of budget_value_type ('ABSOLUTE' or 'MULTIPLIER'), and the optional access_token fallback. It does not mention rate limits or reversibility, but for a create operation, this is reasonably 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 well-structured: a one-line purpose, a brief contextual sentence, a clearly formatted Args list, and a Returns line. Every sentence earns its place, with no fluff or redundancy. It is appropriately sized for the 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 parameters, no annotations, output schema present), the description is complete. It covers all parameters, explains the return value, and provides enough context for an agent to select and invoke the tool correctly. No gaps are apparent.

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 documenting every parameter: campaign_id, budget_value, budget_value_type, time_start, time_end, and access_token. It adds meaning beyond the schema, such as the interpretation of budget_value based on budget_value_type and the Unix timestamp requirement.

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 'Create a budget schedule for a Meta Ads campaign' with a specific verb and resource, and further explains its purpose: 'Allows scheduling budget increases based on anticipated high-demand periods.' This distinguishes it from sibling tools, none of which handle scheduling.

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 implicitly conveys when to use the tool via 'Allows scheduling budget increases based on anticipated high-demand periods,' which is clear context. It also provides practical guidance on Unix timestamps. It does not explicitly mention alternatives or exclusions, but no sibling offers similar functionality, so the guidance is adequate.

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 burden and does well by disclosing critical behavioral traits: it warns about 400 errors for legacy objectives, explains default values (status: PAUSED), clarifies budget usage conditions, and mentions optional token caching. However, it doesn't cover rate limits, authentication requirements beyond token, or error handling details.

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

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

The description is appropriately sized for a complex 15-parameter tool and front-loaded with the core purpose. The parameter explanations are necessary but somewhat dense; some formatting (like the objective list) could be more structured. Every sentence adds value, though the Args: section is lengthy.

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 high complexity (15 parameters, no annotations) but presence of an output schema, the description is quite complete: it covers all parameters thoroughly, explains behavioral constraints, and provides implementation guidance. The output schema likely handles return values, so the description appropriately focuses on input semantics and usage context.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed semantic information for all 15 parameters: it explains formats (e.g., 'act_XXXXXXXXX'), enumerates valid values for objective, clarifies dependencies (e.g., budget parameters only used if use_adset_level_budgets=False), and provides examples for complex parameters like ab_test_control_setups.

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 specific action ('Create a new campaign') and resource ('in a Meta Ads account'), distinguishing it from sibling tools like update_campaign or get_campaigns. The verb+resource combination is precise and 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 implies usage context through parameter explanations (e.g., legacy objectives cause errors) but doesn't explicitly state when to use this tool versus alternatives like update_campaign or create_adset. No explicit when-not 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the tool's dual functionality (comprehensive estimation + backwards compatibility) and mentions token caching behavior. However, it doesn't disclose rate limits, authentication requirements beyond the token parameter, error conditions, or whether this is a read-only vs. write 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 well-structured with clear sections (purpose, args, returns) and efficiently conveys necessary information. While comprehensive, some sentences could be more concise (e.g., 'It also maintains backwards compatibility for simple interest validation' could be simplified). Overall, most content earns its place.

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

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

Given the tool's complexity (6 parameters, no annotations, 0% schema coverage), the description does well by explaining parameters thoroughly and mentioning the return format. However, with an output schema present, it could have been more concise about returns. The description adequately covers the tool's purpose and usage but could benefit from more behavioral context.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed parameter explanations. It clarifies optional vs. required parameters, provides format examples (account_id format), shows a comprehensive targeting example, lists optimization goal options, and explicitly marks deprecated parameters. This adds substantial value 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 specific verb ('estimate') and resource ('audience size') with the exact API used ('Meta's delivery_estimate API'). It distinguishes from siblings by focusing on audience estimation rather than creation, fetching, or updating operations found in other 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 clear context about when to use it ('for targeting specifications') and mentions backwards compatibility for simple interest validation. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for related tasks like searching interests or demographics.

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 of behavioral disclosure. It clearly indicates this is a read operation ('retrieves'), but lacks details on permissions, rate limits, error handling, or response structure beyond basic return values. The example usage helps but doesn't cover behavioral traits comprehensively.

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 clear sections (purpose, args, returns, examples) and front-loaded key information. While slightly verbose with repetitive phrasing ('fetch complete record data' then 'retrieves the full data'), every sentence adds value and the example usage is particularly helpful.

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 (single parameter, read-only operation) and the presence of an output schema, the description is reasonably complete. It explains the parameter thoroughly and indicates the return format, though it could benefit from more behavioral context given the lack of annotations.

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

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

The schema description coverage is 0%, so the description must fully compensate. It provides excellent parameter semantics: it explains the 'id' parameter's purpose, format requirements with concrete examples, and clarifies the colon-separated 'type:id' structure. This adds significant value 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 purpose with a specific verb ('fetch') and resource ('complete record data by ID'), distinguishing it from siblings like 'get_account_info' or 'search' which handle different retrieval patterns. However, it doesn't explicitly differentiate from similar 'get_' tools that might also retrieve records by ID.

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 'get_ad_details' or 'search', nor does it mention prerequisites or exclusions. It simply describes what the tool does without contextual usage information.

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 present, so the description carries the behavioral burden. It discloses the access_token caching behavior, but does not mention permission requirements, error handling, or explicitly confirm read-only semantics beyond the verb 'Get'.

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 front-loaded with the purpose, followed by a compact args section. Every sentence adds value with no 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?

This is a simple read tool with an output schema, so the description need not explain return values. It covers the essential purpose and parameters, but misses an explicit link to related list tools or scenarios, making it slightly incomplete.

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

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

With 0% schema description coverage, the description fully compensates by explaining both parameters: account_id format (act_XXXXXXXXX) and access_token optionality with fallback to cached token.

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 ('detailed information about a specific ad account'), distinguishing it from sibling list tools like get_ad_accounts.

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: use when you need details for a single account given its ID. No explicit alternatives or when-not-to-use conditions are provided, so guidance relies on the clear purpose.

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 disclosing behavior. It notes the optional access_token and cached-token fallback, giving insight into authentication behavior. It also states the return format (JSON). It could mention what happens when no token is available, but for a simple GET operation, this is adequately 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 well-structured with Args and Returns sections, front-loading the purpose. Every sentence provides useful information without unnecessary 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?

For a simple tool with an output schema, the description covers the essential aspects: purpose, parameters, and return value. It is complete enough for an agent to select and invoke the tool correctly, especially given the explicit parameter format and caching note.

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. It explains account_id format (act_XXXXXXXXX) and the optional access_token with caching behavior, adding meaningful context beyond the bare schema. Both parameters are effectively documented.

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 pages associated with a Meta Ads account, using a specific verb and resource. It naturally distinguishes itself from sibling tools like search_pages_by_name by focusing on account association rather than name-based search.

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: when you need pages linked to a specific Meta Ads account. It does not explicitly mention alternatives or exclusions, but the purpose is unambiguous enough to infer the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions optional token caching and default values, which adds some context, but fails to cover critical aspects like authentication requirements (beyond the token), rate limits, pagination behavior, error handling, or what the output contains (though an output schema exists). This leaves significant gaps for safe and effective use.

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 appropriately sized and front-loaded, starting with the core purpose followed by parameter details in a structured 'Args:' section. Each sentence adds value, with no wasted words, though it could be slightly more concise by integrating the purpose and parameters more seamlessly.

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 moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameter semantics well but lacks behavioral context (e.g., auth, limits) and usage guidelines. The output schema mitigates the need to describe return values, but overall, it's adequate with clear gaps for a read operation in a crowded toolset.

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 adds meaningful semantics for all three parameters beyond the schema, which has 0% coverage (titles only). It explains that 'access_token' is optional with caching, 'user_id' can be 'me' for the current user, and 'limit' has a default of 200. This compensates well for the low schema coverage, providing clear usage context without redundancy.

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 with a specific verb ('Get') and resource ('ad accounts accessible by a user'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_account_info' or 'get_account_pages', which might also retrieve account-related information, leaving some ambiguity about its unique scope.

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. With many sibling tools (e.g., 'get_account_info', 'get_account_pages'), there's no indication of how this tool differs in context, such as whether it's for ad-specific accounts or general user accounts, leaving the agent to guess based on the name alone.

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

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

No annotations are provided, so the description carries the full burden. It mentions that 'access_token' is optional and will use a cached token if not provided, which adds useful behavioral context about authentication. However, it doesn't disclose other traits like rate limits, error handling, or response format, leaving gaps for a mutation-free 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a usage guideline and parameter explanations in a structured 'Args:' section. Every sentence earns its place with no wasted words, making it efficient and 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 that there is an output schema (which handles return values), no annotations, and low schema coverage, the description does a good job by covering purpose, usage, and parameter semantics. However, it could be more complete by addressing potential errors or linking more explicitly to sibling tools, but it's largely adequate for a read 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?

Schema description coverage is 0%, so the description must compensate. It adds meaning for both parameters: 'ad_id' is specified as 'Meta Ads ad ID', and 'access_token' is explained as 'Meta API access token (optional - will use cached token if not provided)'. This clarifies semantics beyond the schema's basic types, though it could provide more detail on formats or constraints.

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 creative details for a specific ad.' This is a specific verb ('Get') and resource ('creative details for a specific ad'), making it understandable. However, it doesn't explicitly distinguish it from sibling tools like 'get_ad_details' or 'get_ad_image', which reduces clarity slightly.

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 usage: 'Best if combined with get_ad_image to get the full image.' This gives a helpful guideline on when to use this tool in conjunction with another. However, it lacks explicit alternatives or exclusions, such as when to use 'get_ad_details' instead, which prevents a perfect 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?

Without annotations, the description carries the full burden. It adds useful behavioral context about the access_token parameter, noting that a cached token is used if not provided. However, it does not explicitly mention read-only safety, error handling, or what 'detailed information' includes.

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

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

The description is two sentences plus a clear argument list. It is front-loaded with the purpose statement and concise, with no unnecessary 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?

For a simple single-resource read operation with an output schema, the description is fairly complete. It covers what the tool does, both parameters, and the token fallback behavior. The only notable gap is the lack of usage guidance, which is already penalized under usage_guidelines.

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 descriptions for parameters (0% coverage), so the description fully compensates. It explains ad_id as 'Meta Ads ad ID' and access_token as 'Meta API access token (optional - will use cached token if not provided),' adding semantic meaning beyond the schema's bare type and default.

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.' This distinguishes it from plural listing tools like get_ads and other detail tools like get_adset_details or get_creative_details by specifying 'ad' and 'specific'.

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. There is no mention of alternatives or exclusions, which is problematic given the many sibling 'get_*_details' tools that could be confused.

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?

There are no annotations, so the description bears the full burden. It discloses cached-token behavior and that the result is ready for visual analysis, but it does not explicitly state this is a read-only operation or describe any limitations/errors. These are useful additions but leave some behavioral context unstated.

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

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

The description is compact and well-organized with Args and Returns sections. Every sentence contributes: purpose, usage, parameter guidance, and return behavior. 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?

For a two-parameter tool with no output schema, the description covers purpose, arguments, and return value ('ready for direct visual analysis'). It is sufficient for an agent to invoke the tool, though it could mention error cases or specify the image format.

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 compensates by documenting both arguments. 'ad_id: Meta Ads ad ID' clarifies the identifier, and 'access_token ... will use cached token if not provided' adds the critical optional-token behavior. This goes beyond the bare schema but is not exceptionally 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 uses a specific verb phrase 'Get, download, and visualize a Meta ad image in one step', clearly identifying the resource and action. It differentiates from siblings like get_ad_video and upload_ad_image by emphasizing visual inspection of ad images in the LLM.

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 sentence 'Useful to see the image in the LLM' provides clear when-to-use context for visual verification. It does not explicitly state exclusions or alternatives (e.g., use get_ad_video for videos), but the image-focused wording implicitly distinguishes it from video/upload 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 full responsibility. It explains optional token caching and default limit but omits behaviors like pagination, error handling, or whether only active ads are returned.

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 bullet points and front-loaded purpose. Minor verbosity (e.g., 'optional - will use cached token if not provided') could be trimmed, but overall 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 5 parameters, required account_id, and presence of output schema, the description covers all necessary aspects. It lacks mention of pagination or result scope (e.g., active vs. all ads), but 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?

With 0% schema description coverage, the description fully compensates by detailing each parameter: account_id format, access_token optionality, limit default, and filter fields. Adds significant meaning beyond 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,' specifying the verb, resource, and context. It distinguishes from sibling tools like get_adsets or get_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?

The description lists optional filters but does not explicitly guide when to use this tool versus alternatives like search or get_campaigns. No exclusions or when-not-to-use 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?

With no annotations provided, the description must communicate behavioral traits. It discloses that access_token is optional and will use a cached token if not provided, which is useful. However, it does not mention potential errors, permission requirements, or the read-only nature explicitly (though 'get' implies it). This provides some transparency but leaves 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: a one-sentence purpose, a clear Args list, and an example. It is well-organized and front-loaded with the purpose. No unnecessary wording.

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

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

Given the tool's simplicity and the presence of an output schema, the description is largely complete. It explains the parameters and how to call the function. However, it omits any mention of error conditions or how the response is structured, but the output schema covers that. The description suffices for selection and basic invocation.

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

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

The schema has zero descriptions for its properties, so the description must compensate. It explains adset_id as 'Meta Ads ad set ID' and access_token as an optional token with caching behavior. It also provides a concrete invocation example. This adds significant 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 clearly states the tool's function: 'Get detailed information about a specific ad set.' The verb 'get' and resource 'adset details' distinguish it from sibling tools like get_adsets (which lists adsets) and get_ad_details (which handles ads, not adsets).

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 does not provide explicit guidance on when to use this tool versus alternative tools like get_adsets. It implies you need a specific adset_id, but offers no contextual information about when to choose this over others. The example focuses on invocation syntax rather than selection criteria.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as pagination behavior, ordering, or side effects. It only describes the basic operation (read) without clarifying limits or error handling, which is insufficient given the absence of annotations.

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

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

The description is concise with a single sentence summary followed by a structured Args block. It is front-loaded and every sentence provides useful information, though the Args block slightly repeats schema info without being verbose.

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 simplicity and existence of an output schema, the description covers basic functionality and parameters. However, it lacks context on edge cases (no results), error messages, or rate limits, leaving it minimally complete for a production setting.

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 account_id format ('act_XXXXXXXXX'), access_token optionality with cached token note, limit default, and campaign_id optionality. This adds value beyond the schema, though it could detail limit behavior or filter semantics more.

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 ad sets for a Meta Ads account with optional filtering by campaign.' It specifies the verb 'Get', the resource 'ad sets', the context 'Meta Ads account', and an additional feature. This distinguishes it from siblings like get_ads (different resource) and get_adset_details (specific ad set).

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 mentions optional filtering by campaign but does not explicitly state when to use this tool vs alternatives like get_adset_details or get_ads. There is no guidance on prerequisites or use cases, leaving the agent to infer context from the tool name.

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

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

With no annotations, the description carries the full burden. It discloses that the tool requests a fixed set of fields and notes the availability of other Meta API fields, setting expectations about data completeness. It also explains access_token fallback behavior. However, it does not mention error handling, pagination, or the exact return envelope, leaving some 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 a clear purpose sentence, a useful note about field limitations, and an Args list. The note about modifying the 'fields' parameter in code is slightly tangential for an AI agent but still relevant. It is not overly verbose and each section earns its place.

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

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

Given the simple read-only nature of the tool and the presence of an output schema, the description is reasonably complete. It explains the limited field set, covers both parameters, and notes token caching. However, it lacks explicit guidance on how this tool fits with sibling tools, such as when to prefer get_campaign_details over get_campaigns, which would elevate completeness.

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

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

Schema coverage is 0%, so the description must compensate. It defines campaign_id as 'Meta Ads campaign ID' and access_token as 'Meta API access token (optional - will use cached token if not provided),' adding real semantic meaning not present in the schema. This explains both the purpose and optionality clearly, though it could add constraints like format validation.

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 with a specific verb and resource: 'Get detailed information about a specific campaign.' The word 'specific' explicitly distinguishes it from sibling get_campaigns, which would list campaigns. This makes the tool's scope unambiguous.

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

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

The description implies when to use the tool (when you need details for a specific campaign) and emphasizes 'specific,' but it does not explicitly name alternatives or state when not to use it. No mention of sibling tools like get_campaigns or update_campaign leaves usage guidance implicit rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a read operation (implied by 'Get'), notes API limitations (default fields vs. available fields), explains pagination ('after' parameter), and mentions token caching. It doesn't cover rate limits or error handling, but provides substantial context beyond basic functionality.

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 purpose statement upfront, followed by a note on API limitations, then detailed parameter explanations. Every sentence adds value, though the API note could be slightly more concise. It efficiently conveys necessary information 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?

Given 6 parameters with 0% schema coverage and no annotations, the description does an excellent job explaining inputs and behaviors. The presence of an output schema means return values needn't be described. It covers filtering, pagination, and API quirks, though it could mention error cases or rate limits for full completeness.

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

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

Schema description coverage is 0%, so the description must fully compensate. It does so excellently: each parameter is explained with semantics, formats (e.g., 'act_XXXXXXXXX'), defaults, examples, and usage notes. It clarifies complex behaviors like JSON formatting for 'status_filter' and array/string handling for 'objective_filter', adding significant value 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 purpose: 'Get campaigns for a Meta Ads account with optional filtering.' It specifies the verb ('Get') and resource ('campaigns'), and distinguishes it from siblings like 'get_campaign_details' by focusing on listing/filtering rather than retrieving details. However, it doesn't explicitly contrast with other listing tools like 'get_ads' or 'get_adsets'.

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 the mention of 'optional filtering' and the detailed parameter explanations, suggesting this tool is for retrieving campaigns with specific criteria. However, it lacks explicit guidance on when to use this versus alternatives like 'get_campaign_details' for individual campaigns or 'search' for broader queries. No when-not-to-use scenarios or prerequisites 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 provided, the description carries full burden and does well by disclosing behavioral traits: it explains pagination behavior (using 'after' cursor), default values (limit default 25), API constraints (Meta API allows higher values), and data format specifics (time_range presets, breakdown categories). It doesn't mention rate limits or authentication requirements beyond the optional access_token.

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 appropriately sized for an 8-parameter tool with complex options. It's well-structured with clear parameter sections and bullet points for breakdown categories. Some redundancy exists in listing all breakdown values, but each earns its place by compensating for the 0% schema coverage.

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 (8 parameters, no annotations, 0% schema coverage) but with an output schema present, the description is remarkably complete. It thoroughly documents all parameters with semantics, explains behavioral aspects like pagination and defaults, and provides extensive examples and valid values. The output schema handles return values, so the description appropriately focuses on input semantics and usage context.

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

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

With 0% schema description coverage, the description fully compensates by providing extensive semantic details for all 8 parameters: explains what object_id represents, clarifies access_token optionality with caching behavior, documents time_range formats with examples and preset options, enumerates breakdown categories with detailed valid values, explains level options, specifies limit defaults and API constraints, describes pagination mechanics, and explains action_attribution_windows behavior with field implications.

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 verb 'Get' and the resource 'performance insights' for specific objects (campaign, ad set, ad, or account). It distinguishes from siblings like get_ad_details or get_campaign_details by focusing on performance metrics rather than general object 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 usage for performance insights but doesn't explicitly state when to use this tool versus alternatives like get_ad_details or search_ads_archive. It provides context about what objects it works with but lacks explicit when/when-not guidance or named alternatives.

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 disclosure. It explains the optional access_token behavior ('will use cached token if not provided'), the default limit, and the exact return structure (JSON string with id, name, audience_size, description). This goes beyond basic expectations, though it omits details about error handling or rate limits.

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

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

The description is well-structured with clear Args and Returns sections, front-loaded with a one-sentence purpose. Every piece of information is useful and directly actionable, 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?

The description covers all three parameters, the return format, and operational nuances (token caching, default limit). Combined with the output schema, an agent has everything needed to select and 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?

The schema has 0% coverage, but the description's Args section thoroughly explains each parameter, including examples for interest_list, the optional nature of access_token, and the default for limit. This fully compensates for the schema gap and adds practical guidance.

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 interest suggestions based on existing interests.' This uses a specific verb and resource, distinguishing it from siblings like 'search_interests' by emphasizing it operates on a provided list of interests rather than a free-form search.

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 ('based on existing interests') and implicitly differentiates it from search-like tools. However, it doesn't explicitly state situations to avoid or name alternative tools, so it falls short of full 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 caching behavior (optional access_token, will use cached token) and the return type, but does not explicitly state whether generating the link has side effects (e.g., creates a session, expires) or requires specific permissions. This is a moderate gap.

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, a note, and clear Args/Returns sections. Every sentence adds value and no space is wasted.

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

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

The tool is simple (one optional param), and the description provides usage context, parameter details, and return value. It could mention prerequisites like having a custom Facebook app, but the 'NOTE' section partially covers this. Overall, it is complete for its complexity.

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

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

The schema only provides the parameter name and type, while the description adds meaningful semantics: 'Meta API access token (optional - will use cached token if not provided).' This explains the optionality and fallback behavior, compensating for the schema's minimal 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 clearly states the tool's function with a specific verb and resource: 'Get a clickable login link for Meta Ads authentication.' This unambiguously distinguishes it from the sibling ad-management 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?

Explicit usage guidance is provided: the method should only be used when using your own Facebook app, and the recommended Pipeboard authentication path is described with a concrete alternative (setting PIPEBOARD_API_TOKEN). This is a model of when/when-not 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 of behavioral disclosure. It states that the tool returns matching record IDs, searches across multiple entity types, and clarifies that access_token is optional and uses a cached token if not provided. This adds meaningful context beyond the schema, though it does not cover potential limitations like result limits or pagination.

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

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

The description is well-structured with a concise intro, Args, Returns, and Example Usage sections. The example usage includes five queries, which is slightly repetitive but useful for illustrating query variety. Overall, it is efficient and not verbose.

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, no nested objects) and the presence of an output schema, the description is adequately complete. It covers purpose, parameter semantics, return type, and examples. However, it does not mention pagination, result limits, or error behavior, which are minor gaps.

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

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

The schema has no descriptions (0% coverage), so the description compensates by explaining 'query' as 'Search query string to find relevant Meta Ads records' and 'access_token' as optional with cached-token behavior. This adds clear semantic value beyond the plain schema, though it could provide more detail on query syntax or constraints.

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 through Meta Ads data and return matching record IDs.' It specifies the resource (Meta Ads data) and scope (across ad accounts, campaigns, ads, pages, and businesses), effectively distinguishing it from sibling 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?

The description provides clear context for use through examples like 'search(query="active campaigns")' and 'search(query="facebook pages")', implying it is a broad cross-entity search. However, it does not explicitly state when not to use it or mention alternatives, so it earns a 4 rather than a 5.

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

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

With no annotations, the description must carry behavioral disclosure. It mentions that access_token can be omitted to use a cached token, but it lacks details on pagination, rate limits, or the read-only nature of the operation. The description covers only a small portion of potential behavioral context.

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: a one-sentence purpose, an Args breakdown, and a curl example. The example is somewhat verbose and partially redundant with the Args list, but the overall organization is clear and 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?

The description provides a complete invocation recipe including all parameters, a usage example, and defaults. Since an output schema exists, not detailing return values is acceptable. It lacks some context like pagination behavior, but for a moderately simple search tool 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?

Schema coverage is 0%, but the Args list explains every parameter with examples and formats. For instance, it specifies ad_reached_countries as a list of country codes, ad_type with concrete enum-like examples, and fields as a comma-separated string. 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 'Search the Facebook Ads Library archive,' with a specific verb and resource. This distinguishes it from sibling tools like search_pages_by_name, making it 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 an example and parameter list but does not explicitly explain when to use this tool versus alternatives. There is no mention of exclusions or any guidance on choosing among sibling search 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?

With no annotations provided, the description bears the full burden of behavioral disclosure. It discloses the optional access_token and cached token behavior, plus the return format. However, it does not explicitly state safety characteristics (e.g., read-only) and the phrase 'Get all' conflicts with the limit parameter, leaving some ambiguity.

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 summary, clear args list with descriptions, and a returns line. No unnecessary words 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 description covers the essential aspects: purpose, both parameters, and return format. The 'Get all' vs limit conflict is a minor gap, and pagination behavior is not addressed, but for a simple tool with two optional parameters, 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%, so the description fully compensates. It explains access_token as an optional Meta API token with cached fallback, and limit as the maximum number of results with a default of 50, adding meaningful context beyond the schema's type/default.

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 all available behavior targeting options,' using a specific verb ('get') and resource ('behavior targeting options'). This distinguishes it from sibling tools like search_interests, search_demographics, and search_geo_locations, which target different audience attributes.

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 explicit guidance on when to use this tool versus alternatives. Usage is only implied by the tool name and the description's focus on behavior targeting, but it does not mention alternatives or exclusion criteria.

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

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

With no annotations, the description carries the full burden. It discloses that access_token is optional and that a cached token may be used, which is useful. However, it does not explicitly state that the operation is read-only, nor does it mention pagination behavior, rate limits, or error conditions. The 'Get' verb implies reading, but more explicit behavioral context would be beneficial.

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 clear Args and Returns sections. Every sentence contributes essential information, with no redundancy or fluff. It is succinct yet comprehensive, fitting the ideal length for a tool with three parameters.

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

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

The description covers all parameters and the return value structure, which is sufficient for a search-like tool with no nested objects. However, it lacks details on potential pagination (beyond the limit parameter) or rate limiting, which might be relevant for large result sets. An output schema exists, so return type is further clarified, but the absence of explicit edge-case behavior keeps it from being a 5.

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 every parameter: access_token's optional nature and fallback behavior, demographic_class with its enumerated options and default, and limit with its default. This exceeds what the schema alone provides and gives clear semantic meaning.

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

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

The description clearly states the tool retrieves demographic targeting options with the verb 'Get' and a specific resource. It is unambiguous, but it does not explicitly differentiate itself from sibling tools like search_interests or search_behaviors; the distinctiveness comes from the resource name rather than the description itself.

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 such as search_interests, search_behaviors, or search_geo_locations. It only describes the function itself, leaving the agent to infer usage context 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?

With no annotations provided, the description carries the full burden. It discloses access_token caching behavior, returns a JSON string with location data, and implies a read-only search operation. While it doesn't mention rate limits or pagination, it provides solid transparency for a search 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 uses a clean, structured Args/Returns format. Every line earns its place, listing parameters and return value without any 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 the tool's purpose, all parameters, token handling, and return structure. Given the tool's simple search nature and no annotations, this is complete enough for an agent to select and invoke it correctly.

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

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

The input schema has 0% description coverage, but the description fully compensates by explaining each parameter: query, access_token, location_types (including available options), and limit with default. This adds complete semantic meaning beyond the bare 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 'Search for geographic targeting locations' with a specific verb and resource. This distinguishes it from sibling search tools like search_interests and search_behaviors, making the tool's scope unambiguous.

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

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

The description clearly indicates this is for geographical targeting locations, which gives clear context for when to use it. However, it does not explicitly mention alternatives or exclusion criteria, only implying the use case through the resource type.

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

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

With no annotations, the description carries the burden. It discloses that the access token is optional and a cached token is used, and describes the return format with specific fields. It does not explicitly state whether the operation is read-only or mention error conditions, but the search verb implies non-destructive 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 structured with Args and Returns sections, front-loads the core purpose in one sentence, and every line adds necessary information without fluff.

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 search tool with three parameters, the description covers the purpose, parameters, return format, and auth context. It lacks explicit pagination details but is otherwise complete enough 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?

The schema lacks parameter descriptions, but the tool description compensates fully: it defines the query with examples, explains the access_token optional behavior, and specifies the limit's default. This adds meaningful semantics 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 starts with a specific verb and resource: 'Search for interest targeting options by keyword.' This clearly distinguishes it from sibling tools like search_behaviors and search_demographics, which target different categories.

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 keyword-based interest searches but does not explicitly explain when to prefer this tool over alternatives like search_behaviors or search_geo_locations. It offers no when-not 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 must carry the burden. It discloses some behaviors: access_token can be omitted and 'will use cached token if not provided', and search_term is optional with a defined fallback. However, it does not mention authentication requirements, rate limits, permissions, or response structure beyond 'JSON response with matching pages'.

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 uses a structured Arg/Returns format that is easy to scan. It is concise with no superfluous content, though the docstring formatting adds some lines. Overall it earns its place.

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

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

For a simple search tool with 3 parameters and an output schema, this description is sufficiently informative. It covers all parameters and the return type, plus the account_id format. Minor gaps exist (no pagination, no error behavior), but these are not critical 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?

Schema coverage is 0%, so the description compensates. It explains all three parameters: account_id with format 'act_XXXXXXXXX', access_token with cached-token fallback, and search_term with behavior when omitted. However, it lacks details on search_term matching semantics (e.g., exact vs substring, case sensitivity).

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.' The verb 'search' and the resource 'pages' with the qualifier 'by name' make the purpose specific and distinguish it from siblings like 'get_account_pages' 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?

The description implies usage context by explaining optional parameters (e.g., 'returns all pages if not provided'), but it does not explicitly state when to use this tool versus alternatives or mention any exclusions. No direct references to 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Update' implies mutation, the description doesn't specify permission requirements, whether changes are reversible, rate limits, error conditions, or what happens to existing ad settings not mentioned. For a mutation tool with 6 parameters and no annotation coverage, this is a significant gap in behavioral context.

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 clear purpose statement followed by well-organized parameter explanations. Every sentence earns its place, and the bullet-point style for parameters makes it scannable. No wasted words or 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?

Given this is a mutation tool with 6 parameters, no annotations, but with an output schema (which means return values are documented elsewhere), the description is moderately complete. It covers parameter semantics well but lacks behavioral context, usage guidelines, and differentiation from siblings. The presence of an output schema helps, but for a complex update operation, more contextual information would be beneficial.

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 provides excellent parameter semantics despite 0% schema description coverage. It clarifies that 'ad_id' is a 'Meta Ads ad ID', 'bid_amount' is 'in account currency (in cents for USD)', 'tracking_specs' are 'Optional tracking specifications (e.g., for pixel events)', and 'creative_id' 'changes the ad's image/content'. This adds substantial meaning beyond the bare schema, though it doesn't cover all parameters equally (status explanation is minimal).

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 verb ('Update') and resource ('an ad with new settings'), making the purpose immediately understandable. However, it doesn't differentiate this tool from its sibling 'update_ad_creative' beyond the resource name, missing explicit distinction about what makes this ad update different from creative updates.

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 about when to use this tool versus alternatives like 'update_ad_creative' or 'update_adset'. The description lacks context about prerequisites, dependencies, or scenarios where this specific ad update tool is appropriate versus other update operations in the system.

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 burden for behavioral disclosure. It states this is an update operation (implying mutation) but doesn't mention permission requirements, whether changes are reversible, rate limits, error conditions, or what happens to unspecified fields. The 'Returns' section mentions JSON response but lacks detail on success/failure patterns. For a mutation tool with 11 parameters and zero annotation coverage, this is insufficient.

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 clear sections (purpose, Args, Returns) and uses bullet-like formatting for parameters. Each parameter explanation is concise yet informative. The opening sentence clearly states the tool's purpose. However, the parameter section is quite long (11 items), which is necessary given the complexity but affects overall brevity.

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

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

Given the tool's complexity (11 parameters, mutation operation, no annotations), the description does well on parameter semantics but lacks behavioral context. The presence of an output schema means the description doesn't need to detail return values, but it should address mutation-specific concerns like permissions, idempotency, and error handling. The parameter documentation is comprehensive, but behavioral transparency gaps remain.

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 provides extensive parameter documentation beyond the 0% schema description coverage. It explains creative_id is the 'Meta Ads creative ID to update', clarifies optionality of access_token, distinguishes between headline/headlines and description/descriptions with mutual exclusivity rules, explains lead_gen_form_id requirements for specific CTA types, and gives context for dynamic_creative_spec. 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 'Update an existing ad creative with new content or settings' - a specific verb (update) and resource (ad creative). It distinguishes from siblings like create_ad_creative (creation vs update) and update_ad/adset/campaign (different resource types). However, it doesn't explicitly contrast with get_ad_creatives or other read operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing creative), when to choose update_ad_creative over create_ad_creative, or how it relates to other update operations like update_ad. The only implicit guidance is in the name itself - updating vs creating.

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 burden. It states this is an update operation which implies mutation, but doesn't disclose behavioral aspects like: whether changes are reversible, what permissions are required, rate limits, whether partial updates are allowed (vs full replacement), or how the targeting parameter 'will replace existing targeting' affects the operation. The description provides some behavioral hints but misses critical mutation context.

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 appropriately front-loaded with the core purpose, but the parameter documentation section is lengthy (though necessary given schema coverage). While each parameter explanation earns its place, the overall structure could be more concise by grouping related parameters or using bullet points. It's functional but not optimally streamlined.

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 (11 parameters, mutation operation, no annotations) and the existence of an output schema, the description does substantial work. The parameter documentation is comprehensive, and the output schema will handle return values. However, for a mutation tool with no annotations, it could better address behavioral aspects like error conditions, idempotency, or side effects.

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 provides extensive parameter documentation with 11 parameters, adding significant semantic value beyond the schema which has 0% description coverage. Each parameter gets clear explanations, examples, and important details like currency units (cents), replacement behavior for targeting, and optional token usage. 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 the verb 'update' and resource 'ad set' with specific settings mentioned (frequency caps and budgets). It distinguishes from siblings like 'create_adset' by focusing on updates, but doesn't explicitly contrast with other update tools like 'update_ad' or 'update_campaign' beyond the resource type.

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

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

No guidance on when to use this tool versus alternatives like 'update_ad' or 'update_campaign'. The description mentions what parameters can be updated but provides no context about prerequisites, dependencies, or when this specific update operation is appropriate versus other update operations in the sibling set.

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 burden. It implies mutation ('update') but doesn't disclose behavioral traits like required permissions, rate limits, idempotency, or error handling. It does add some context about optional parameters and budget removal, but lacks comprehensive behavioral disclosure for a complex 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 appropriately sized for 13 parameters, using a clear 'Args:' section with bullet-like formatting. It's front-loaded with the core purpose, though some explanations could be more concise (e.g., repetitive 'in account currency' phrases). 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?

Given the tool's complexity (13 parameters, mutation operation, no annotations) and the presence of an output schema, the description is reasonably complete. It thoroughly documents parameters and hints at behavioral aspects (e.g., optional token caching, update constraints). However, it lacks explicit guidance on usage context and full behavioral transparency.

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 adds significant semantic value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose, format (e.g., 'in cents as a string'), special cases (e.g., empty string to remove budgets), and constraints (e.g., 'may not always be updatable' for objective). 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 the tool's purpose: 'Update an existing campaign in a Meta Ads account.' It specifies the verb ('update') and resource ('campaign'), but doesn't explicitly differentiate it from sibling tools like 'update_ad' or 'update_adset', which would require mentioning it's specifically for campaigns rather than ads or adsets.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, constraints, or compare it to sibling tools like 'create_campaign' or 'update_adset'. The agent must infer usage from context 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 the full burden. It discloses input formats (data URL/base64/file URL), optional token behavior with caching fallback, and the return format including the hash for creative creation. This goes beyond basic visibility, though it doesn't mention rate limits or conflicts when both file and image_url are provided.

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, using a clear Args/Returns format. The example data URL is valuable without being verbose. 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 and the return's purpose, and an output schema exists. However, it doesn't specify the relationship between 'file' and 'image_url' (whether at least one is required, or what happens if both are provided). This is a notable gap for a tool whose sole purpose is uploading an image.

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 does so thoroughly: account_id format (act_XXXXXXXXX), access_token caching behavior, file data URL/base64 formats with example, image_url semantics, and name default. Each parameter gets meaningful guidance beyond the schema's bare 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 gives a specific verb (upload), resource (image), and purpose (use in Meta Ads creatives), distinguishing it from read-oriented sibling tools like get_ad_image and get_ad_video.

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 noting the return includes 'hash for creative creation,' situating it in the creative-creation workflow. However, it does not explicitly name alternatives or state when not to use it, so usage guidance is clear but not fully explicit.

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