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 only mentions the env var requirement and doesn't disclose behavior for edge cases (e.g., duplicate user, invalid role), side effects, or return values. For a mutation tool, this is a significant 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?

Two short, direct sentences with no filler. The description is front-loaded with the action and includes a critical prerequisite in the second sentence.

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 two-parameter tool with fully described schema, the description covers the main operation and prerequisite. However, the lack of any behavioral or return details makes it merely adequate rather than thorough.

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 100% for both parameters, so the schema already documents email and role. The description adds minor context (configured business, by email) but does not go beyond the schema for parameter 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 action ('Add') and the resource ('a user to the configured business') with a specific method ('by email'). It distinguishes itself well from sibling tools like remove_business_user and list_business_users.

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

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

The description provides a prerequisite (META_BUSINESS_ID env var) but does not explicitly contrast with alternatives or state when to use this tool over others. Usage is implied by the clear action and sibling context, but no explicit guidance is given.

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

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

With no annotations, the description carries the burden. 'Add... to an existing block list' clearly indicates a mutation, but it does not disclose side effects, idempotency, whether duplicates are allowed, or if changes are reversible. This is minimal but not misleading; it provides the core behavioral trait (adding URLs) but lacks deeper disclosure.

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

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

A single, clear sentence with no filler or redundancy. It fully captures the action and scope without 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?

For a simple two-parameter mutation, the description is adequately complete: it names the action, the resource, and the precondition ('existing'). No output schema is present, so return details are not required. The sibling tools provide additional context for list management, but the description itself is sufficient for basic use.

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 100% with descriptions for both parameters. The description adds extra meaning by specifying 'publisher URLs' (not just any URLs) and 'existing' block list (not creation). This goes beyond the schema's generic 'Block list ID' and 'URLs to block', enriching the semantic context.

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 the specific verb 'Add' and clearly states the resource: 'publisher URLs to an existing block list.' This distinguishes it from sibling tools like create_block_list (new list), remove_from_block_list (removal), and list_block_lists (listing).

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 'existing block list' implies the tool is for modifying an already-created list, which gives some context. However, it does not explicitly mention alternatives or when not to use this tool (e.g., use create_block_list if the list doesn't exist). Sibling names provide hints but the description itself offers no direct guidance beyond the implied precondition.

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 partially carries the transparency burden by specifying that the payload must be hashed and formatted as a JSON string with a schema. However, it does not disclose side effects, prerequisites (e.g., audience must exist), idempotency, or error behavior, leaving significant gaps for a mutating 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 two sentences, with the primary action front-loaded and the payload constraint stated in a single additional sentence. There is no filler or redundancy, making it maximally efficient for its 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 simple 2-parameter mutation tool, the description covers the core action and essential payload format, but omits details like response behavior, whether the audience must pre-exist, and handling of duplicate users. Given no annotations or output schema, a slightly richer description would be expected 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 coverage is 100%, so both parameters are documented. The description adds a concrete example of schema values (EMAIL, PHONE, FN, LN) that supports but mostly repeats the schema's payload description. It does not introduce new semantic meaning beyond highlighting the hashing requirement, which is already in the schema.

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

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

The description uses a specific verb ('Add') and names both the resource ('users') and target ('custom audience'), making the tool's function immediately obvious. It also distinguishes this from sibling tools like remove_users_from_audience and create_custom_audience by showing it adds to an existing audience.

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 (adding users to an audience) but provides no explicit guidance on when to use this tool versus alternatives, such as create_custom_audience or update_audience. There are no stated exclusions or conditions, so the usage context is only implied by the tool name and action.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses the batch limit and upsert support, but omits crucial details such as whether operations are atomic, error handling, authentication requirements, or the asynchronous nature (given the sibling get_batch_status).

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

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

Two concise sentences deliver the essential information without redundancy. It is front-loaded with the core function and immediately adds limits and upsert behavior, making every word useful.

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 involves batch mutations and there is a sibling tool get_batch_status, but the description doesn't mention that results might be retrieved separately or how errors are reported. It covers limits and upsert but leaves out lifecycle details, which are significant for a batch 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?

The input schema already documents all three parameters with clear descriptions (requests format, catalog_id, allow_upsert). The description only reinforces the upsert behavior already captured in allow_upsert, adding no new semantic meaning beyond the schema.

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

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

The description clearly specifies the tool's function: batch create, update, or delete products in a catalog. It distinguishes from single-product siblings by emphasizing batch capability and includes concrete limits (5,000 items) and upsert behavior.

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 this is the batch variant for product operations, but it doesn't explicitly compare to single-product tools or feed upload alternatives. It doesn't state when NOT to use it or mention alternative tools, so guidance is 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?

No annotations are provided, so the description carries the burden. It mentions the core behavior (creates a duplicate) but does not disclose nuances like whether all fields are copied, the independence of the copy from the source, or permission requirements. It's adequate but not rich.

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

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

Two concise sentences front-load the primary purpose and the key variation (same/different ad set). Every word earns its place, with no redundancy or unrelated information.

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

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

For a simple copy tool with fully documented parameters, the description covers the main action and scope. However, it lacks any mention of return values (e.g., new ad ID) or side effects, and with no output schema, this leaves a gap for the agent.

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 100%, and the description does not add semantic meaning beyond the schema. The adset_id parameter's behavior (same/different ad set) is already documented in the schema, so the tool description adds no extra value here.

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?

Description clearly states the action ('Copy an existing ad') with a specific resource, and adds scope ('within the same or different ad set') that differentiates it from create/update/delete ad tools. It's a specific verb+resource pairing.

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

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

The usage is implied by the description — copying an ad when you want a duplicate. However, there is no explicit guidance on when to prefer this over create_ad or update_ad, nor any alternatives mentioned.

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

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

With no annotations, the description must disclose side effects. It states 'Creates a duplicate' but omits critical behaviors such as deep_copy defaulting to true (copying internal ads) and status defaulting to PAUSED, which significantly affect the operation's outcome.

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

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

A single, front-loaded sentence with no redundant terms. It efficiently communicates the core action and key option.

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

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

The tool has 5 parameters, no output schema, and no annotations, yet the description only covers the basic purpose. It does not explain important behavioral defaults like deep copy or paused status, leaving an agent without critical information for invocation.

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

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

Schema coverage is 100% as every parameter has a detailed description including defaults and behavior ('If omitted, copies to same campaign'). The tool description adds no additional meaning beyond the schema.

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

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

The description identifies a specific action ('Copy'), a resource ('ad set'), and a key variable ('same or different campaign'), clearly distinguishing it from sibling tools like copy_campaign and copy_ad.

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

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

The description implies usage when duplicating an ad set and clarifies the same/different campaign option, but does not explicitly state when not to use it or mention alternatives like create_adset.

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

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

No annotations are provided, so the description must disclose behavioral traits. It states the action (copy/duplicate) and what is copied, but does not mention side effects such as whether the original is modified, required permissions, cost implications, or the return value (e.g., new campaign ID). This is a significant gap for a mutation tool.

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

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

The description is two short sentences with no filler. It leads with the core action and follows with key details, making it highly efficient 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?

Given the tool has 4 parameters and no output schema, the description should explain the return value and side effects. It covers the main functionality but omits what is returned (e.g., new campaign ID) and whether the original is untouched. It is adequate for basic understanding but incomplete for a copy 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 100%, so the baseline is 3. The description adds minimal context by mentioning 'optional name override' and 'copies structure including ad sets and ads', which loosely maps to the name and deep_copy parameters. It does not provide additional syntax or formatting details beyond the schema, hence the baseline score.

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 copies an existing campaign, with a specific verb and resource. It also distinguishes from sibling copy tools by noting it copies structure including ad sets and ads, making its 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 usage: it is for copying an entire campaign, not just an ad set or ad. However, it does not explicitly mention alternatives like copy_adset or copy_ad, nor does it provide when-not-to-use guidance. The context is clear but not contrasted with other copy tools.

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

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

No annotations are provided, so the description carries the full burden. It mentions the default PAUSED status, but that is already in the schema. It omits permissions, rate limits, side effects, dependency on an existing adset, and error behavior—significant gaps for a mutation tool.

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

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

Two front-loaded sentences with no filler. The second sentence largely repeats schema facts (required fields, default status), so it does not fully earn its place, but the overall structure is efficient.

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

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

The rich schema (100% coverage) compensates for the short description, but with no output schema and no annotations, the description leaves behavioral context, return value expectations, and creation prerequisites unstated. Adequate but with clear gaps.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters including creative and account_id. The description only repeats required fields and the default status, adding no meaning beyond what the schema already provides.

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

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

The description states a specific verb ('Create') and resource ('ad'), clearly distinguishing it from siblings like create_campaign, create_adset, and create_creative. It does not explicitly name or contrast with any sibling, which keeps it from a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives (e.g., create_creative first, update_ad, copy_ad). It only lists required parameters, which is schema information rather than usage context.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the creation default ('Defaults to PAUSED status'), which tells the agent the new ad set will not immediately spend, but omits permissions/auth requirements, whether creation is idempotent, and what happens on failure.

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

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

Two short sentences, no padding, with the core action front-loaded and the operational default (PAUSED) trailing. Every clause carries information.

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

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

For a 21-parameter create tool with no annotations and no output schema, the description is thin: it never states what is returned (e.g. the new ad set ID) nor flags interplay among the budget/bid_strategy parameters. The rich schema compensates for parameter detail, but the description leaves the agent to infer creation behavior and outcome.

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 100%, so the schema already documents all 21 parameters in depth, setting the baseline at 3. The description only restates a subset of required fields and adds no syntax or format meaning beyond the schema.

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

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

States a specific verb and resource ('Create a new ad set'), which clearly separates it from create_campaign, create_ad, and update_adset by noun. It does not explicitly name or contrast with any sibling, but the resource is unambiguous enough that an agent can select it correctly.

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

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

The description lists required fields but gives no when-to-use guidance, no prerequisites, and no alternatives (e.g. update_adset vs create_adset). It also references a 'budget' requirement that does not map to any single parameter (there are daily_budget, lifetime_budget, and bid_amount), so the guidance it does offer is imprecise.

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, and it does disclose the most important trait: the operation is asynchronous and yields a report_run_id that must be polled via get_async_report. It omits secondary operational context such as whether the report expires, expected latency, permission requirements, or that all 8 parameters are optional (notably no default time window is stated).

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

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

Two short sentences with zero filler; the purpose and scope lead, and the essential follow-up action (polling) is stated second. Nothing is redundant with the schema.

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

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

There is no output schema, and the description compensates by naming the returned handle (report_run_id) and the tool that consumes it, which is the one piece an agent must know to use this correctly. Remaining gaps — report lifetime, latency, and error behavior — are minor against a 100%-documented input schema.

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

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

Schema description coverage is 100% and all 8 parameters are self-documented (including the env-var fallback for account_id and the breakdown opt-in caveat). The description adds no parameter-level meaning at all, so the baseline 3 for a fully-documented schema is appropriate.

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

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

States a specific verb and resource ('Create an async insight report') plus a scope qualifier ('for large data queries'), which differentiates it from the many synchronous insight siblings like get_account_insights. It names get_async_report but as the polling follow-up rather than as the alternative it replaces, so the differentiation from sync insight tools is implied rather than stated.

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

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

'for large data queries' gives a clear selection condition and the second sentence tells the agent exactly what to do next (poll with get_async_report). However, it never states when NOT to use this tool — e.g. that smaller queries should use get_account_insights/get_campaign_insights instead — so the alternative routing is left to inference.

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

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

With no annotations, the description carries the full burden: it implies mutation but says nothing about required permissions, whether list names must be unique, whether duplicates overwrite or error, or what is returned. For a write tool with zero annotation coverage this is a significant 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?

A single front-loaded sentence with no waste. It is efficient, though the brevity is partly the cause of the missing guidance rather than a virtue in itself.

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 mutation tool with no annotations and no output schema, the description should say what a successful creation yields (e.g. an ID) and how errors/duplicates behave. None of that is present, leaving the agent under-informed about outcomes.

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 100%, with both name and account_id fully documented in the schema, including the env-var fallback for account_id. The description adds no parameter meaning beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Create a new publisher block list') scoped to the ad account, which distinguishes it from list_block_lists, add_to_block_list, and delete_block_list. It doesn't explicitly name those siblings, but the create verb makes the distinction clear.

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

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

No guidance on when to use this versus the sibling block-list tools, nor any prerequisites such as needing an existing ad account or how block lists are then populated via add_to_block_list. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of disclosure and offers only 'create a budget schedule'. It says nothing about the mutating effects, required permissions on the parent object, validation rules (e.g. time_start before time_end), or whether an existing schedule is replaced.

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

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

A single front-loaded sentence with no filler. It is efficient, though the extreme brevity is arguably under-specification rather than disciplined conciseness given the tool's complexity.

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

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

For a six-parameter mutation tool with five required fields, no annotations and no output schema, the description omits the temporal constraint linking time_start/time_end, the meaning of a MULTIPLIER versus ABSOLUTE budget, and the parent_type default. An agent could not call this correctly from the description alone.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including budget_value_type semantics and the Unix timestamp format. The description adds no parameter-level meaning beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description gives a specific verb ('Create') and resource ('budget schedule') plus the owning scope ('on a campaign or ad set'), so the agent knows exactly what object is produced. It does not explicitly distinguish itself from the nearby siblings (list_/update_/delete_budget_schedule), but the create verb makes the intent 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?

There is no guidance on when to use this tool versus update_budget_schedule, or on the precondition that a campaign/ad set must already exist. Usage can only be inferred from the tool name, and no alternative is ever named.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the PAUSED default and that budgets can live at either campaign or ad set level, but it says nothing about required permissions, side effects, failure modes, or reversibility of a mutation.

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

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

Four short sentences, front-loaded with the operation and default status, with zero filler. Every sentence carries a distinct piece of information (what, default state, required fields, budget placement).

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

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

For a 13-parameter mutation tool with no output schema, the description covers the essentials while the very detailed schema carries the tricky edge cases (Meta-required special_ad_categories, is_adset_budget_sharing_enabled failures). An agent has enough to call it correctly, though the description itself does not surface those gotchas.

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 100%, so the rich per-field documentation (spend_cap immutability, special_ad_categories requirement, bid_strategy pitfalls) already lives in the schema. The description only reiterates name/objective as required and the budget-level choice, adding little beyond that baseline.

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

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

States a specific verb and resource ('Create a new ad campaign'), so the operation is unambiguous. It does not, however, differentiate itself from the several sibling creation tools (create_adset, create_ad, copy_campaign), leaving the agent to infer the hierarchy from names alone.

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

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

Usage context is only implied by the verb 'Create'. The note that 'Budget can be set at campaign or ad set level' hints at a design decision, but there is no explicit guidance on when to create a campaign vs. an ad set, or when copy_campaign would be preferable.

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 for behavioral disclosure. It only says 'Create a new Instant Experience' and lists required parameters, but does not mention side effects, permissions, idempotency, or what happens after creation. For a mutation tool, this is a notable 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 two concise sentences, immediately states the core purpose, and includes only essential parameter requirements. No filler or redundant content.

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

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

While parameters are well documented in the schema, there is no output schema and the description does not explain the return value (e.g., a canvas ID) or any authentication requirements. For a create operation, this missing information makes the description incomplete for an agent to fully understand the tool's behavior.

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 100%, so the schema already documents all three parameters. The description adds 'JSON array defining the canvas layout' for body_elements, which is consistent with the schema but does not provide significant new meaning beyond it.

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

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

The description opens with a specific verb and resource: 'Create a new Instant Experience (Canvas) on a Facebook Page.' This clearly states the action and target, and distinguishes it from sibling tools like get_canvas, list_canvases, and delete_canvas.

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

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

There is no guidance about when to use this tool versus alternatives like get_canvas or list_canvases. The description only mentions required parameters ('Requires page_id and body_elements') but does not provide usage context, exclusions, or alternative comparisons.

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

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

No annotations are provided, so the description carries the full behavioral burden. It identifies this as a create operation and scopes it to an ad account, but it does not disclose required permissions, duplicate-name handling, side effects, or what happens on success or failure.

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

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

The description is a single front-loaded sentence with no wasted words. Its brevity suits a simple create tool whose parameter details are handled by the schema.

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

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

For a simple 3-parameter create tool with full schema coverage, the description is adequate but incomplete. It lacks usage guidance and behavioral details, and because no output schema exists, it also does not indicate what a successful creation returns.

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 100%, so the schema already documents name, vertical values, and the account_id fallback behavior. The description only adds the phrase "for the ad account," which is marginal beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: "Create a new product catalog," and scopes it to "the ad account." It is clear what the tool does, but it does not explicitly distinguish itself from sibling catalog tools like list_catalogs, get_catalog, or update_catalog.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as list_catalogs or update_catalog. It implies creation, but does not state prerequisites, exclusions, or the conditions under which a new catalog should be created.

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 and discloses real behavioral traits: poll_spec and poll interactive_components are rejected in v26.0, and shop-eligible creatives silently default to WEBSITE_AND_SHOP unless opted out. It omits auth/permission requirements and rate/return behavior, but the version-specific rejection and defaulting behavior is substantive.

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

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

Front-loaded with the core purpose and spec definition, followed by dense but specific version notes. Every sentence carries operational information; the version block is long but earns its place by stating what will be rejected and what changes by default.

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

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

For an 8-parameter mutation with 100% schema coverage and no output schema, the description covers the key behavioral gotchas (rejections, defaults/opt-out) an agent would otherwise miss. It stops short of stating permission requirements or the response, minor gaps given the rich schema.

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

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

Schema coverage is 100%, so the schema already documents all 8 parameters (including destination_spec and wamo_whatsapp_identity_spec guidance). The description's restatement of object_story_spec content types and the WEBSITE_AND_SHOP default adds marginal meaning beyond the schema, fitting the baseline 3.

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

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

States a specific verb+resource ('Create a new ad creative') and immediately characterizes the required payload, explaining what object_story_spec is (link/photo/video content plus the Facebook Page). It does not explicitly distinguish itself from the sibling create_dynamic_creative, which also creates creatives, so sibling differentiation is missing.

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

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

Usage is implied by the ad-creation flow and the v26.0 default-shop note gives one conditional ('If the advertiser has a shop...'), but there is no explicit when-to-use versus create_dynamic_creative or update_creative, and no named alternative for dynamic creatives.

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 at all, the description carries the full behavioral burden and delivers very little: it does not state permission requirements, that this is an irreversible write, which fields are mandatory per subtype (pixel_id for WEBSITE, rule for engagement/video), or what happens when a required companion field is missing. The "validate-only is not supported" caveat lives in the schema, not the description.

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

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

Two short sentences with the core action front-loaded and the subtype semantics attached directly to it. No filler and nothing an agent must read past to find the important constraint.

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

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

For an 8-parameter, no-annotation, no-output-schema mutation tool with subtype-conditional required fields, the description is too thin. It never explains which parameters become mandatory for which subtype, which is the single most likely source of a failed call.

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

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

Schema description coverage is 100%, so the baseline is 3, and the description adds meaning the schema lacks by explaining that subtype is a causal selector of the audience source. It stops short of covering the other seven parameters, so it is a modest rather than comprehensive uplift.

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

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

States a specific verb and resource ("Create a new custom audience") and immediately explains that subtype drives the audience source. It does not differentiate itself from the sibling create_lookalike_audience, even though LOOKALIKE appears in its own subtype enum, which leaves a real ambiguity unresolved.

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

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

No when-to-use guidance and no comparison against alternatives such as create_lookalike_audience or list_custom_audiences. The only contextual hint is that subtype determines the source, which is a mechanic rather than guidance about when to pick 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?

No annotations, so the description carries the burden. It discloses the useful behavioral trait that Meta automatically combines assets, but omits permissions/auth needs, the account_id env-var fallback, validation behavior, and what a successful call yields.

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

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

Two tight sentences with the purpose front-loaded and the mechanism following; zero filler.

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

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

For a 7-parameter creation tool with no annotations and no output schema, the description should say more about the optional specs (destination_spec, degrees_of_freedom_spec, wamo_whatsapp_identity_spec) and the return value. The rich schema partially compensates.

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 100%, so the schema itself documents all seven parameters. The description's mention of images, videos, titles, bodies and CTAs largely restates the asset_feed_spec schema description, adding little new semantics.

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

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

States a specific verb and resource ('Create a dynamic creative') and explains the distinguishing mechanism (Meta auto-combines assets). This separates it from the generic sibling create_creative, though it never names that sibling explicitly.

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

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

Usage is only implied by the 'dynamic creative' framing; there is no explicit when-to-use-this-vs-create_creative guidance, no prerequisites, and no mention of what happens if asset_feed_spec is incomplete.

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

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

Since there are no annotations, the description carries the full burden of behavioral disclosure. It does not inform the agent about the side effects, necessary permissions for mutation, or any critical failure behaviors associated with creating a live ad study.

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

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

It is a single, highly efficient sentence that front-loads the necessary action and resource name. There is zero waste in the language used.

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

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

As a complex, mutation-based operation (creating an experiment), the definition is lacking in completeness. It does not provide necessary context about dependencies, scope, or potential impact beyond the basic definition.

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 100%, meaning all parameter definitions are handled comprehensively by the structured input schema. As such, the description adds no additional semantic value to the parameters.

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

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

The description uses a specific verb ('Create') and clearly identifies the resource ('A/B test experiment' or 'ad study'). This verb explicitly distinguishes it from sibling functions like 'list_experiments' or 'get_experiment'.

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 is purely declarative and offers no guidance on when to use this tool versus alternatives. It fails to specify prerequisites or constraints, such as when an existing experiment must be updated instead of created.

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 only states the creation action and does not disclose side effects, required permissions, validation behavior, or return value. This is insufficient for a mutation tool.

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

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

A single concise sentence that gets straight to the point with no filler. Front-loaded with the action and resource.

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

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

The description is too sparse for a create operation with no output schema or annotations. It does not explain what constitutes a feed, how file_url and schedule relate, or what the response looks like. There is also no mention of prerequisites like an existing catalog.

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 already describes all four parameters with 100% coverage. The description adds no additional meaning beyond the parameter names, so it relies entirely on the schema's minimal 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 it creates a new product feed for a catalog, using a specific verb and resource. It is differentiated from related feed operations like upload_feed or list_feeds by the explicit 'create' action.

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

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

No guidance is given on when to use this tool versus alternatives such as upload_feed or update_catalog. The context implies creation of a new feed, but there are no explicit exclusions or conditions.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only mentions the required permission and the basic creation action. It does not describe the return value, side effects, error handling, or any constraints beyond permission, leaving significant 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 a single sentence that conveys the essential information without any wasted words. It includes the action, resource, location, and a key prerequisite, 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 the tool has 6 parameters (4 required), no output schema, and no annotations, the description is insufficiently complete. It lacks information about the return value, error scenarios, or any additional behavioral context needed for correct invocation.

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

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

The schema description coverage is 100%, so the baseline is 3. The description adds no parameter-level detail beyond what the schema already provides, thus not meeting the higher bar for compensation.

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

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

The description clearly specifies the action (create), the resource (lead generation form), and the location (on a Facebook Page), distinguishing it from list/get siblings. It also mentions required permission, which adds clarity.

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 states a prerequisite (pages_manage_ads permission) but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. The context is clear, but no exclusions or alternative comparisons are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only notes the ratio's effect, omitting permissions, mutation effects, account fallback behavior, and return characteristics. It also says ratio is '1-10' while the schema defines it as 0.01-0.10, creating 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?

Two concise sentences with the core purpose and key behavioral note front-loaded. No wasted text.

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 create/mutation tool with no annotations and no output schema, the description covers the source audience and ratio but leaves important operational context unexplained, such as account fallback behavior and what happens on success or failure.

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 100%, so the schema already documents all four parameters. The description adds a note about ratio but does not meaningfully document the other parameters and its ratio scale conflicts with the schema's percentage range.

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

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

The description gives a specific verb and resource: 'Create a lookalike audience based on an existing custom audience.' It clearly distinguishes this from creating a custom audience, though it does not name the sibling tool explicitly.

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

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

Usage is implied: use this when you want to derive a lookalike audience from an existing custom audience. However, there are no explicit when-not conditions, prerequisites, or named alternatives to guide selection.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only implies a create mutation; it does not disclose required auth, duplicate-name handling, whether the operation is reversible, or what happens to existing data.

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

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

A single sentence with no filler. It is front-loaded and zero-waste, though it is arguably too sparse to be fully 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?

For a create tool with no annotations and no output schema, the description is too thin. It omits prerequisites, side effects, and any sense of how the created set relates to offline event sending, leaving the agent under-informed for a mutation 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 100%, so the schema already documents name, account_id, and description. The description adds no parameter-level meaning beyond the action itself, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource: create a new offline conversion data set. It does not, however, distinguish this from sibling tools like list_offline_event_sets or send_offline_event, so an agent must infer the difference from the name alone.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g., required permissions or an existing account), and no alternatives named. The agent is left to guess whether this is the right tool for setting up offline conversion tracking.

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 but only states the core action. It does not disclose side effects, required permissions, idempotency, or error conditions. For a write operation, this is insufficient 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 a single, front-loaded sentence with no wasted words. It clearly communicates the action without unnecessary padding.

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 lacks context about return values, prerequisites (e.g., existing catalog ID), or filter format details. Since no output schema exists, the agent gets no indication of what to expect after creation, which is a notable gap for a 3-parameter tool.

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

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

The input schema provides 100% parameter description coverage. The tool description adds no additional parameter context beyond what is already in the schema, so the baseline 3 applies.

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 'Create' with a clear resource 'product set' and context 'within a catalog', which distinguishes it from sibling tools like update_product_set or list_product_sets.

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 does not mention that this is for creating a new set while update_product_set modifies existing ones, leaving the agent to infer usage from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about required permissions, whether the prediction runs asynchronously, what identifier is returned, or whether the prediction persists as a billable object. Only the parameter-adjacent hints (cents, JSON string) are offered.

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

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

Two short sentences with zero filler and the core action front-loaded. It is efficient, though the second sentence is a loose enumeration that omits half the required 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?

This is a seven-parameter, six-required mutation tool with no annotations and no output schema, so the description should do more. It omits required inputs such as frequency_cap and destination_id, says nothing about the account_id fallback or the shape of the result, leaving an agent under-informed about what a successful call produces.

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 100%, so the schema already documents all seven parameters including the account_id env-var fallback and the ISO 8601 / Unix formats. The description repeats a subset (targeting spec as JSON string, budget in cents, scheduling info) but adds no syntax or constraints beyond the schema, so the baseline 3 applies.

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

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

States a specific verb ('Create') and resource ('reach & frequency prediction'), and the verb itself distinguishes it from the sibling read/delete tools list_rf_predictions, get_rf_prediction and delete_rf_prediction. It does not, however, explicitly differentiate itself from other creation or estimation siblings such as get_reach_estimate.

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

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

No when-to-use guidance is given. The description never explains when a reach & frequency prediction is the right choice versus get_reach_estimate, get_delivery_estimate, or creating an experiment, nor does it state prerequisites.

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

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

Since no annotations are provided, the description carries the full burden of transparency. It does not disclose behavioral traits such as required permissions, mutation consequences, or error handling.

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

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

The definition is maximally concise, consisting of a single, clear sentence that immediately conveys the tool's function without any filler.

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

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

Given that this is a complex mutation operation involving multiple JSON specification strings, the description should provide more context about prerequisites or operational constraints, which it fails to do.

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 100%, meaning the schema already documents the parameters adequately. The description adds no meaningful semantic meaning beyond what the input structure defines. Baseline score is correct.

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 ('Create') and identifies the exact resource ('automated rule'). It successfully differentiates this tool from its siblings like list_rules and update_rule.

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

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

The description only states what the tool does, not when to use it. There is no guidance to differentiate between creating a new rule and modifying an existing one (update_rule sibling).

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 the required env var, but does not disclose permissions, idempotency, conflict handling, or side effects beyond the creation itself. For a mutation tool, this is a significant 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 two short sentences that front-load the action and scope, then state a key requirement. No filler or redundant wording; every word earns its place.

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

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

For a simple create tool with fully documented parameters, the description covers essential purpose and a prerequisite. However, it omits expected return behavior, potential duplicate-name errors, and does not clarify how it differs from similar user-creation tools, leaving some uncertainty for an agent.

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 100% with both parameters (name and role) described inline. The description adds no additional parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action 'Create' and the resource 'new system user', and scopes it to 'the configured business'. This distinguishes it from sibling tools like add_business_user, which likely targets business users rather than system users.

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

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

No guidance is given on when to use this tool versus alternatives like add_business_user or list_system_users. The only contextual clue is the META_BUSINESS_ID env var requirement, but there is no explicit when-to-use or what-not-to-use direction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions the credential requirement (META_APP_ID and META_APP_SECRET) and indicates what the tool inspects (properties, permissions, expiration, validity). However, it does not explicitly state whether the operation is read-only, potential side effects, or response format, 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 two sentences long, front-loaded with the core purpose, and the credential requirement is presented succinctly. Every sentence earns its place, and there is no unnecessary elaboration.

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

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

Although there is no output schema, the description specifies what information the tool provides ('properties, permissions, expiration, and validity'), which effectively covers the return content. It also notes the required credentials. For a simple one-parameter, read-only tool, this is reasonably complete, though it could explicitly mention response format or error behavior.

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 100% coverage for the single parameter 'input_token' with description 'Access token to debug/inspect'. The description does not add any additional parameter meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Debug an access token to inspect its properties, permissions, expiration, and validity.' This is a specific verb with a clear resource and scope, and it distinguishes itself from sibling token tools like exchange_token and refresh_token by focusing on inspection rather than token lifecycle management.

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

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

The description implies usage through its purpose ('Debug an access token...'), but it does not explicitly state when to use compared to alternatives like exchange_token or refresh_token. It provides a prerequisite ('Requires META_APP_ID and META_APP_SECRET') but lacks explicit 'when to use' or 'when not to use' guidance.

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

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

With no annotations, the description must disclose behavioral traits itself. It does state that the action is irreversible, which is a critical trait, but omits other relevant behaviors such as required permissions, potential cascading deletions, or success/error responses.

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

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

The description is extremely concise, with two short sentences and no wasted words. The primary action is front-loaded, and the irreversibility warning is placed efficiently.

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 one-parameter delete operation, the description covers the essential action and irreversibility. It is almost complete, though it could mention what happens to associated data or the return value, but this is a minor gap given the tool's simplicity.

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 100% coverage for the single parameter, with ad_id described as 'Ad ID to delete'. The description adds no extra meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Delete an ad') with a specific verb and resource, distinguishing it from sibling tools like get_ad, update_ad, and copy_ad. The added warning about irreversibility further reinforces the purpose.

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

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

No explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. While deletion intent is implied by the verb, the description does not mention that this is for permanent removal or advise using update_ad for modifications.

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

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

The description discloses that deletion is irreversible, a critical behavioral trait. However, with no annotations, it doesn't mention other potential consequences (e.g., impact on associated ads) or permission requirements, leaving some behavioral 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 two short sentences with no redundancy. The irreversibility warning is meaningful and earns its place, making it highly concise and well-structured.

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

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

For a one-parameter delete operation, the description and schema cover basic invocation, but the lack of any context about when deletion is appropriate or cascading effects leaves some gaps. Adequate but not comprehensive.

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 100% and the description adds no meaning beyond the schema's 'Ad set ID to delete'. The parameter is fully documented, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Delete an ad set' with a specific verb and resource, distinguishing it from sibling delete operations like delete_campaign or delete_ad. The irreversibility note adds clarity about the action's nature.

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 such as update_adset or delete_campaign. There are no prerequisites, conditions, or exclusions mentioned, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full burden. It explicitly states the action is irreversible, which is a critical behavioral trait beyond what the schema provides. However, it could mention side effects or authorization requirements, but for a simple delete this is sufficient.

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 short sentences with no redundant information. Every word earns its place, making it concise and well-structured.

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

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

For a simple delete operation with one parameter and no output schema, the description covers the essential purpose and the key caveat (irreversibility). While it could mention what happens to related data, the simplicity of the tool makes this adequate.

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 covers the single parameter (audience_id) with a clear description. The tool description adds no additional parameter semantics, but the baseline of 3 applies given 100% schema coverage.

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

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

The description clearly states the action ('Delete') and the resource ('a custom audience'), distinguishing it from sibling tools that create, get, list, update, or manage audiences. It is specific 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 for when deletion is needed, but does not explicitly state when to use it versus alternatives or provide exclusions. The irreversibility warning hints at caution but does not give context like 'use only if you no longer need the audience'.

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 explicitly states that the action is irreversible, which is a critical behavioral trait for a delete operation. It does not mention permissions or cascade effects, but for a simple 1-parameter delete, this is sufficient.

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 short sentences with no filler. The primary purpose is front-loaded, and the irreversibility warning adds necessary context without verbosity.

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 (1 parameter, no output schema), the description is complete. It states the action and its irreversible nature, which is all the agent needs to know for correct invocation. The lack of sibling differentiation is a minor gap but does not affect the core completeness for this straightforward delete 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?

The input schema already provides a description for the single parameter list_id ('Block list ID to delete'), giving 100% schema coverage. The tool description adds nothing beyond the schema, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Delete') and resource ('publisher block list'), clearly distinguishing it from sibling operations like create_block_list, add_to_block_list, and remove_from_block_list. It also adds the irreversibility warning, further clarifying the action.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as remove_from_block_list. The description only states what the tool does, not the context or exclusions. The irreversibility warning implies caution but does not provide usage direction.

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

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

With no annotations, the description must carry the full behavioral burden. It discloses a key trait—irreversibility—which is critical for a delete operation. However, it does not mention permissions, effects on linked resources, or what happens if the schedule is in use, 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 two sentences long, front-loaded with the action, and every word is purposeful. The irreversibility warning is concise yet meaningful, achieving maximum clarity in minimal space.

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 delete operation with one parameter and no output schema, the description covers the essential purpose and a key consequence. It does not explain what a budget schedule is or prerequisites, but the sibling tools provide enough context to infer usage. Minor omissions like the return value or not-found behavior prevent a higher 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?

The schema already provides 100% coverage of the single parameter (schedule_id) with a clear description. The tool description adds no additional semantics about the parameter, so it meets the baseline but does not enhance understanding.

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 ('Delete') and a clear resource ('budget schedule'), making the tool's purpose immediately obvious. It also adds the caveat 'irreversible' for emphasis, distinguishing it from create/update/list siblings without confusion.

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 (delete when you want to remove a budget schedule) but does not explicitly state when to use it versus alternatives or provide prerequisites. The irreversibility warning is a caution, not a usage guideline, so it falls short of clear context with exclusions.

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

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

The description discloses that the action is irreversible, which is a critical behavioral trait. However, with no annotations provided, it does not disclose other potential consequences like cascading deletion of associated adsets/ads or permission requirements. It covers the most obvious risk but leaves other behaviors 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 only two sentences, front-loaded with the verb and resource, and the second sentence about irreversibility adds meaningful value without waste. It is appropriately concise.

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 parameter, no output schema), and the description states its primary purpose and its irreversible nature. However, given the absence of annotations, it does not address potential side effects on related objects or expected response on success/failure, leaving some ambiguity for a destructive 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?

The schema includes a single required parameter `campaign_id` with a description, and the schema coverage is 100%. The tool description adds nothing about the parameter's meaning beyond what the schema already specifies, so baseline 3 applies.

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

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

The description states the specific action ('Delete') and resource ('a campaign'), clearly distinguishing it from other campaign-related tools like get_campaign or update_campaign. The resource is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives such as update_campaign (to change status) or delete_adset. It lacks any contextual cues about prerequisites or when deletion is appropriate.

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

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

The description discloses the critical behavioral fact that deletion is irreversible, but with no annotations available, it does not cover other important aspects like permissions, side effects, or return behavior.

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

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

Two sentences, front-loaded with the action, and the irreversibility warning is concise and relevant. 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?

For a simple delete tool with one parameter, the description covers the action and key warning, but lacks details on return values or prerequisites, and there is no output schema or annotations to fill the 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 input schema already documents the canvas_id parameter with a description, and the tool description does not add any additional parameter-level information. Since schema coverage is 100%, the baseline score of 3 applies.

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

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

The description clearly states the action (delete) and the specific resource (Instant Experience/Canvas), which distinguishes it from sibling tools like get_canvas and create_canvas.

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 deletion but does not provide explicit guidance on when to use this tool vs alternatives, nor any prerequisites or exclusions.

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

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

With no annotations present, the description carries the full burden, and it does disclose the most important trait for a destructive operation: irreversibility. It omits other behavioral context such as permission requirements and any cascade effect on ads/creatives that reference the image.

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

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

Two short sentences, zero filler, with the destructive nature front-loaded. Nothing could be removed without losing information.

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

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

Adequate minimum for a two-parameter destructive tool whose params are fully documented, but for an irreversible delete with no annotations and no output schema, an agent would benefit from knowing required permissions and whether dependent ads break.

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 100%, so both 'hash' and the optional 'account_id' (with its env-var fallback) are already documented in the schema. The description adds nothing about parameter format or the fallback behavior, so it sits at the baseline.

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

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

States a specific verb ('Delete') and resource ('ad image') with the identifying key ('by hash'). It is clearly distinguishable from siblings like get_image, list_images, upload_image and delete_video, though it does not name any sibling explicitly.

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

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

No guidance on when to use this versus alternatives, no prerequisites, and no warning about which ads or creatives may reference the image. The agent must infer everything 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 provided, the description carries the full burden of behavioral disclosure. It adds a key warning that the action is irreversible, which is significant. However, it does not disclose other potential side effects, error handling, or permissions, leaving gaps in 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 two concise sentences: the first states the purpose, the second adds a critical warning. There is no redundant information, and it is front-loaded with the action and resource.

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 (one parameter, no output schema, no annotations), the description covers the essential information: what it does and that it is irreversible. It is complete enough for an agent to understand the tool's function, though it could mention prerequisites or side effects for full comprehensiveness.

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 already fully describes the only parameter (prediction_id) as 'Prediction ID to delete'. The description adds no additional meaning beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Delete') and the specific resource ('reach & frequency prediction'). It unambiguously distinguishes this tool from sibling tools like list_rf_prediction, create_rf_prediction, and get_rf_prediction.

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

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

The description implies usage when a reach & frequency prediction needs to be permanently removed, but it does not explicitly mention when-not to use it or name alternative tools. The context is clear but no exclusions or alternatives are provided.

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

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

There are no annotations, so the description must carry the full burden of behavioral disclosure. It states only the destructive action ('Delete') without mentioning irreversibility, side effects, authorization requirements, or consequences. This is minimal and largely restates the obvious.

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

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

The description is a single, front-loaded sentence with no wasted words. For a simple delete operation, this level of conciseness is appropriate 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?

For a one-parameter, simple delete tool, the core action is communicated adequately. However, the lack of any indication about permanence, response behavior, or failure conditions leaves some contextual gaps, especially given the complete absence 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?

Schema coverage is 100% for the single parameter rule_id, so the schema already documents it. The description adds no extra meaning beyond confirming the target of deletion, matching the baseline of 3.

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 ('Delete') and resource ('automated rule'), clearly distinguishing it from siblings like create_rule, update_rule, get_rule, and list_rules. It states exactly what the tool does with no ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any prerequisites or exclusions. The usage context is only implied by the tool name and description, not explicitly 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?

The description discloses that the action is irreversible, which is valuable behavioral context. However, with no annotations, it fails to mention potential cascading effects, such as what happens to ads referencing the video, or whether special permissions are required.

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 short, front-loaded sentences with no fluff. It states the action and the critical caveat in an efficiently structured manner.

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 delete tool, it covers the key trait (irreversibility) but lacks details about dependent resources, success/error responses, or prerequisites. Given there is no output schema, more context would improve 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?

The schema already provides 100% coverage for video_id with the description 'Video ID to delete'. The tool description adds no meaningful parameter semantics beyond implying the video is an ad video, so it does not exceed the baseline.

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 the specific verb 'Delete' with a clear resource ('an ad video'), making it immediately obvious what the tool does. It distinguishes itself from sibling delete tools like delete_ad or delete_image by specifying '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?

No guidance is provided on when to use this tool versus alternatives. There are many delete tools among siblings (e.g., delete_ad, delete_image), and this description does not clarify when delete_video is the appropriate choice or mention any exclusions.

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

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

No annotations exist, so the description carries the full burden of disclosing behavior. It mentions a configuration requirement but does not state what the exchange does beyond the token conversion, whether it is a read-only operation, what the response contains, or any side effects. This is a significant gap for an authentication-related 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 two sentences, each serving a purpose: one states the core function, the other notes a necessary configuration. There is no redundancy or filler, making it appropriately concise 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?

For a simple single-parameter tool, the description covers the main action and a key requirement. However, it omits information about the returned token, potential errors, and the broader context of when to use this exchange. Since there are no annotations or output schema, the description could be more complete, earning a mid-range 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?

The schema describes the parameter 'short_lived_token' fully (100% coverage), and the description's phrase 'short-lived access token' aligns with the schema. The description does not add extra semantic details about the parameter beyond what the schema provides, so the baseline score of 3 applies.

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

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

The description clearly states the action ('Exchange') and the specific resources ('short-lived access token' to 'long-lived token'), making the tool's purpose unmistakable. It is specific enough to distinguish from related token tools like refresh_token and debug_token, even though alternatives aren't named.

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 the usage context (when you have a short-lived token and need a long-lived one) and provides a key prerequisite (META_APP_ID and META_APP_SECRET configured). However, it does not explicitly mention when to use this tool versus refresh_token or debug_token, nor any exclusions.

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

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

No annotations are present, so the description carries the full burden. It usefully discloses that no prior ad object is required, but says nothing about side effects, rate limits, or authentication beyond what the schema states. For a no-annotation tool the disclosure is partial.

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

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

Two short sentences, zero filler, with the differentiating qualifier front-loaded immediately after the verb. Nothing in it is redundant with the title or name.

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

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

There is no output schema, so the description should characterize what a preview returns (image/URL/iframe payload), and it only offers the vague 'see how it would look'. Inputs and the no-existing-ad behavior are adequately covered, but the artifact an agent will receive is left undefined.

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 100% and each of the three parameters is documented in the schema, including the env-var fallback for account_id and the accepted creative spec shapes. The description's 'provide creative spec directly' adds no syntax or format detail beyond that, so baseline 3 applies.

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

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

States a specific verb and resource (generate an ad preview) and adds a meaningful scope qualifier: 'without needing an existing ad', which separates it from the sibling get_ad_preview. It does not name that sibling outright, so an agent must infer the pairing rather than being told.

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?

'Provide creative spec directly' tells the agent the required input posture, and 'without needing an existing ad' defines the situation that selects this tool over get_ad_preview. The alternative tool is not named, so the routing is implied rather than explicit.

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

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

With no annotations, the description carries the full burden; 'Get' implies a read-only operation, and the second sentence discloses the kind of events returned (changes to campaigns, ad sets, ads). It says nothing about permission requirements, retention window, or how pagination behaves beyond the schema fields, so disclosure is partial rather than rich.

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

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

Two short sentences, front-loaded with the core purpose and with zero filler. The second sentence earns its place by naming the object types covered. Could be marginally tighter but is well-structured.

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

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

With no output schema and no annotations, the description is the only source of behavioral context, and it stops at naming the log's subject matter. It omits return shape, whether results are chronological, and any indication of scope defaults (e.g., all activities vs. a window), which an agent would need.

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 100% – all four parameters (after, limit, fields, account_id) are documented in the schema, including the env-var fallback for account_id. The description adds no parameter-level meaning, so the baseline 3 is appropriate.

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

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

Clear specific verb+resource: 'Get activity log for the ad account' tells the agent exactly what it retrieves. The second sentence clarifies the log's contents (campaign/ad set/ad changes), distinguishing it conceptually from insight tools like get_account_insights. However, it does not name any sibling explicitly, so an agent must still infer the boundary.

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

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

There is no when-to-use guidance, no mention of when to prefer this over get_account_insights or get_campaign, and no prerequisites stated. The only implicit cue is the phrase 'activity log,' leaving the agent to guess the appropriate context.

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

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

No annotations are provided, so the description bears the full behavioral burden. It discloses the returned metrics, which is mildly useful, but says nothing about whether this is a read-only operation, required permissions, pagination/row limits, or the caveat that empty results may not mean zero performance (that caveat lives only in the schema).

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

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

Two short, front-loaded sentences with no padding; the purpose is stated first. The 'etc.' trailing example list is slightly loose but harmless.

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

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

With 8 optional parameters, no output schema, and no annotations, the description is thin: it hints at return content but omits pagination behavior, the interaction between date_preset/time_range/time_increment, and any dependency on account-level defaults. The rich schema compensates for most parameter detail, but the behavioral picture remains 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?

Schema description coverage is 100% across all 8 parameters, so the schema already documents levels, fields, filtering, breakdowns, date ranges, and time increment. The description's metric list loosely maps to the `fields` default but adds no syntax, defaults, or constraints beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('performance insights for the ad account') and gives examples of returned metrics. However, it does not differentiate itself from the sibling insight tools (get_campaign_insights, get_adset_insights, get_ad_insights), and 'for the ad account' is misleading given the `level` param allows campaign/adset/ad aggregation, so an agent could confuse it with those siblings.

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 offers no when-to-use guidance, no exclusions, and never names the alternative insight tools. An agent must infer from the name alone that this is the account-scoped variant rather than the campaign/adset/ad ones.

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

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

The verb 'Get' implies a read-only operation, but with no annotations, the description carries the full burden. It does not disclose what fields are returned by default, error behavior, or that it returns a single object. No side effects are mentioned, but the verb suggests none.

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

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

The description is a single, front-loaded sentence with no filler words. It is appropriately concise for a simple getter operation.

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 with well-documented parameters, but the description lacks context about what 'details' includes, how the fields parameter affects the response, and how it differs from sibling getters like get_campaign_ads. Without an output schema, the description could be more explicit about the return shape.

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 100% coverage for both parameters (ad_id and fields), so the description need not repeat them. It adds no extra meaning beyond the schema, such as examples or constraints, but the baseline is 3 given the high schema coverage.

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

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

The description clearly states the action ('Get'), the resource ('details of a specific ad'), and the identifier ('by ID'). It distinguishes this from sibling list tools like list_ads and get_campaign_ads by emphasizing a single ad lookup.

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

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

The description implies usage when you have a specific ad ID and need its details, which is clear context. However, it does not explicitly mention alternatives or when not to use it, such as using list_ads for multiple ads. No exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only operation by saying 'Get details,' but does not disclose permissions, rate limits, error behavior, or whether changes are made. It adds field examples but no real 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 a single front-loaded sentence with no redundant or filler content. Every part contributes to identifying the resource and the fields returned.

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 read tool with no output schema and no annotations, the description gives the core fields but not the full return shape or any behavioral caveats. It is adequate but leaves some gaps that an agent might need when interpreting results.

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 100%, so both parameters are already documented in the input schema, including the account_id env-var fallback. The description adds no parameter syntax or usage details beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states a specific verb ('Get') and resource ('configured ad account') and lists concrete fields, so an agent can tell it retrieves one account rather than listing many. However, it does not explicitly name the sibling alternative list_ad_accounts, leaving that differentiation implicit.

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

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

There is no explicit guidance about when to use this tool versus list_ad_accounts or other account-related siblings. The phrase 'configured ad account' hints at scope, but no alternatives, prerequisites, or exclusions 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 at all, the description carries the full behavioral burden and delivers almost nothing: no statement of read-only safety, no auth/permission requirements, no rate-limit or timeout guidance (notable for an insights endpoint where large queries typically require an async report), and no sense of what the response contains.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though the brevity is partly under-specification rather than disciplined conciseness.

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

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

For an 8-parameter analytics tool with no annotations and no output schema, sitting in a family of four near-identical insight tools, the description omits everything an agent needs beyond the schema: when to prefer it over the sibling insight tools, the interaction between ad_id and level, and how to handle queries too large for a synchronous call.

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

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

Schema description coverage is 100%, so all 8 parameters (including the nuanced breakdowns and date_preset options) are already documented in the schema. The description adds no parameter meaning at all, so the baseline 3 applies.

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?

Clear verb+resource ('Get performance insights') with a scoping qualifier ('for a specific ad') that separates it from the account/campaign/adset insight siblings. It stops short of naming those siblings or explaining the level parameter's role, so differentiation is implied rather than stated.

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

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

No when-to-use guidance, no exclusions, and no mention of the obvious alternatives (get_account_insights, get_campaign_insights, get_adset_insights) or of create_async_report for heavy queries. The agent must infer routing from the tool name alone.

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

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

With no annotations provided, the description carries the full burden. It discloses that the output is an HTML iframe for rendering, but omits any information about side effects, authentication requirements, whether the preview is static or live, or any limitations. Minimal behavioral transparency beyond the return type.

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

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

The description is a single, concise sentence that is front-loaded with the primary purpose. Every word earns its place, with no wasted text.

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 two-parameter tool, the description provides the essential purpose and return type. However, it lacks any broader context, such as typical use cases, prerequisite conditions, or potential edge cases, leaving some gaps for a complete understanding.

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

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

Both parameters (ad_id, ad_format) are fully described in the input schema with 100% coverage. The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves a preview of an ad in a specified format, with a concrete return type (HTML iframe). It is specific about the verb and resource, though it does not explicitly distinguish itself from the sibling tool 'generate_preview'.

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 generate_preview or get_ad. There are no conditions, exclusions, or context for appropriate usage.

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

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

No annotations are present, so the description carries the full burden. It merely states 'Get details,' implying a read operation, but does not disclose default fields, response format, permissions, or how the 'fields' parameter affects the output. The agent is left to infer 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 a single concise sentence, front-loading the action and resource with no extraneous words. It is efficient, though it could incorporate a bit more contextual detail without becoming 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?

For a simple get-by-ID tool with full parameter schema, the description is minimally adequate. However, with no output schema and no annotations, it lacks information about the return value structure, what 'details' includes, and when to use this tool over siblings, which is a notable gap.

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

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

The input schema provides descriptions for both parameters (adset_id and fields), achieving 100% schema coverage. The description adds little beyond reinforcing the 'by ID' aspect, so it does not compensate for any gaps in schema semantics.

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

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

The description clearly states the action ('Get') and resource ('ad set'), specifying that it targets a specific ad set by ID. It does not explicitly differentiate from sibling tools like list_adsets or get_campaign_adsets, but 'specific' and 'by ID' imply a single-entity fetch.

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 such as list_adsets or get_campaign_adsets. The description lacks context about prerequisites or typical use cases, leaving the agent without decision support.

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 for behavioral disclosure. It does not mention that this is a read-only operation, nor does it explain pagination (via 'after' and 'limit'), the meaning of 'all' relative to pagination, or any response structure. The description is too sparse to set expectations for the agent.

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

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

The description is a single sentence with no filler, front-loading the core purpose. It is appropriately sized for the tool's simplicity, though it could benefit from more detail without becoming 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?

For a list-type tool with a simple 4-parameter schema and no output schema, the description is minimally acceptable but leaves gaps. It fails to mention that results are paginated (despite the 'all' wording), which could mislead the agent into expecting a single unbounded response. The schema helps, but the description should complement it with behavioral notes.

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 100%, so all parameters (adset_id, after, limit, fields) are already documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, aligning with the baseline of 3.

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

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

The description uses a specific verb 'Get' and resource 'ads' with scope 'belonging to a specific ad set', clearly distinguishing it from sibling tools like get_campaign_ads or list_ads. It is concise 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 when you have an ad set ID and need its ads, but it does not explicitly state when to use this tool versus alternatives or mention exclusions. No alternative tools are referenced, so guidance is minimal but not misleading.

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