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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the description only needs to add context — and it does: it discloses that native X fields and pagination structure are preserved, and that monetary fields suffixed _micro are millionths of the account currency. That unit convention is real behavioral information an agent cannot get from the annotations, though rate limits and pagination mechanics remain 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?

Two short sentences with no filler, and the core purpose is front-loaded. The second sentence is slightly run-on ('account Native X fields') and could be split, but nothing is wasted.

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

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

An output schema exists, so return-value shape need not be described, and the full input schema covers all required parameters with constraints. The description supplies the two things structured fields cannot: the preserved-pagination/native-field behavior and the _micro monetary unit convention.

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 every one of the eight required parameters is already documented, including enum constraints for entity, placement and granularity. The description adds no parameter-level detail beyond the _micro currency convention, which relates to output rather than input, so the schema baseline 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?

States a specific verb and resource ('Get synchronous analytics (impressions, engagements, spend) for an ads account'), so an agent knows exactly what comes back. It does not differentiate itself from the closest sibling, x_ads_get_campaign_reach, which also returns performance figures.

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 call this versus x_ads_get_campaign_reach or the list/get entity endpoints. The word 'synchronous' hints at a contrast with async reporting, but the agent must infer that; no exclusions or prerequisites are stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld, so the safety profile is covered. The description adds genuinely non-structured context: response shape is native X fields with pagination preserved, and money fields suffixed _micro are millionths of the account currency — a unit convention an agent would otherwise mishandle. It does not mention result-size limits or rate limits, keeping it at 4.

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 purpose before the workflow hint and format notes. Dense but every clause carries information. The parenthetical interrupts the main clause slightly and it packs three distinct ideas (purpose, sequencing, units/format) into very little text without clear separation.

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

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

With an output schema present, return values needn't be spelled out, and the description still adds the useful _micro unit rule and pagination note. Purpose plus sequencing plus format notes cover what an agent needs to select and call it correctly; only edge cases (empty result meaning, window size limits) are unaddressed.

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

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

Schema description coverage is 100% and the per-parameter docs are strong (hour-aligned ISO 8601 windows, enum for entity, exclusivity and 200-max on the id filters), so the schema carries the load. The description adds no per-parameter meaning beyond the _micro output convention, 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 — lists ad entities whose metrics changed within a time window — which an agent can distinguish from the list_* siblings that enumerate entities outright. It also implicitly contrasts itself with x_ads_get_account_stats via the parenthetical. Slightly indirect phrasing ('which ads entities had metrics change') 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 parenthetical '(use before requesting account stats)' gives explicit sequencing guidance that routes the agent to call this before x_ads_get_account_stats, which is a real workflow constraint. It stops short of stating when NOT to use it or naming the alternative as a full either/or, so 4 rather than 5.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds genuine context beyond them: that native X fields and pagination are passed through unchanged and that _micro monetary fields are millionths of the account currency, which an agent needs to interpret values correctly.

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

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

It is short and front-loads the purpose, but the sentences are run together without punctuation ("by ID Native X fields..."), which blunts readability of the units caveat. Every clause is useful; the structure is the weak point.

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

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

With an output schema present and rich annotations, the description needn't describe return shape, and it does supply the one interpretive detail the schema can't convey (the _micro unit convention). Only the absence of routing guidance toward the list sibling keeps it from a 5.

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

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

Schema description coverage is 100%, covering account_id, campaign_id and the with_deleted default, so the baseline is 3. The description only echoes the by-ID semantics and adds nothing about with_deleted or the account scoping beyond what the schema states.

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?

"Get a single campaign by ID" gives a specific verb (get), resource (campaign) and scope (single, by ID), which implicitly separates it from the sibling x_ads_list_campaigns. It does not explicitly name the sibling, so it falls just short of a 5.

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

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

Usage is only implied: an agent infers it should call this when it already holds a campaign_id and wants one record rather than a list. There is no explicit when-to-use/when-not, no mention of prerequisites, and no pointer to x_ads_list_campaigns as the alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and non-destructive behavior, so the safety profile is covered. The description adds real value with the _micro currency-unit convention and the note that native X fields and pagination are preserved, but it says nothing about how reach is computed, rate limits, or cardinality of results.

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

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

Purpose is front-loaded in the first clause and the total length is two sentences. The second sentence is awkwardly spliced (missing punctuation between "campaigns" and "Native X fields"), which slightly hurts readability.

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

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

An output schema exists, so return values need not be explained, and the schema fully documents all four required parameters. The description covers purpose plus data-format conventions; only the semantics of "reach" and any result-size expectations are left implicit.

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 schema itself documents the ISO 8601 window, the 20-campaign cap, and the past-only end_time rule. The description adds no parameter-level meaning beyond that, 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 and resource ("Get reach and average-frequency metrics for campaigns"), which clearly separates it from entity-fetch siblings like x_ads_get_campaign and aggregate siblings like x_ads_get_account_stats. It does not explicitly name an alternative, so it falls short of a 5.

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

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

There is no statement of when to use this tool versus x_ads_get_campaign, x_ads_get_account_stats, or x_ads_get_line_item, and no prerequisites or exclusions beyond what the schema implies. The second sentence covers data conventions, not usage 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?

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is fully covered. The description adds a genuinely useful data-semantics note about _micro monetary units, but the claim that 'pagination is preserved' is confusing on a single-item fetch and goes unexplained.

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

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

It is short, but the first sentence is malformed — 'Get a single card by ID Native X fields and pagination are preserved' runs two clauses together with no punctuation, hurting front-loading. The pagination clause is also noise for a single-item get.

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

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

For a simple read-only single-entity lookup with an output schema and fully documented parameters, the definition covers what an agent needs to invoke it. The one remaining gap is not explaining the account_id/card_id relationship or the soft-delete default's effect on output.

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%, with card_id, account_id and with_deleted all documented in the schema including the soft-delete default. The description adds no parameter-level meaning beyond that, so the baseline 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?

States a specific verb and resource: 'Get a single card by ID'. The singular 'single card' implicitly contrasts with the sibling x_ads_list_cards, though it never names it.

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 'by ID' — an agent can infer this is the lookup path when it already has a card_id, but there is no explicit statement of when to use this versus x_ads_list_cards or how to obtain a card_id.

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

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

Annotations already establish readOnly, idempotent, and non-destructive behavior, so the bar is low, yet the description adds genuinely useful context that the annotations do not: native X fields and pagination are preserved, and monetary fields ending in _micro are in millionths of the account currency. That unit note materially reduces misinterpretation of returned values.

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 clauses with no filler, leading with the core action. Minor deduction for the run-on punctuation that makes the second clause read awkwardly.

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

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

An output schema exists, so return structure need not be explained, and all three params are schema-documented; the description supplies the one thing an agent could misread (the _micro currency units). A brief mention of the soft-delete flag would make it fully complete.

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

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

Schema description coverage is 100%, so account_id, line_item_id, and with_deleted are all documented in the schema and baseline 3 applies. The description adds no parameter-level detail beyond the ID concept and does not mention the soft-delete option.

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 ('Get a single line item by ID'), which cleanly separates it from the list-oriented sibling x_ads_list_line_items. It stops short of naming the sibling, so a 4 rather than 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?

Usage is only implied: an agent can infer this is the tool for a single known line_item_id versus x_ads_list_line_items, but the description never states that condition or any prerequisite. No explicit when-to-use or when-not guidance is present.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description still adds genuinely useful context not in the annotations: native X fields are preserved, and monetary fields ending in _micro are millionths of the account currency — a non-obvious unit convention an agent would otherwise misinterpret.

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

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

It is short and front-loads the action, but the sentence runs on without punctuation — 'by media key Native X fields and pagination are preserved' reads ambiguously, as if 'Native X fields' were part of the lookup rather than a separate note. Size is right; the structure is sloppy.

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

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

An output schema exists and carries return-value detail, and the input schema documents both required parameters, so little is missing. The only loose end is the mention of pagination for a single-item fetch, which is unexplained and mildly confusing.

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%, with both required parameters fully documented (media_key and account_id including the X_ADS_ACCOUNT_IDS source). The description adds nothing beyond repeating 'by media key', 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+resource (get a single media library object) and the key used to identify it. It does not explicitly name x_ads_list_media_library as the alternative, but the singular-vs-list contrast is easy to infer from the sibling names.

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?

Implied usage only: retrieve one item when the media_key is already known. There is no explicit statement of when to use this instead of x_ads_list_media_library or x_ads_get_media_upload_status, and no preconditions such as whether the key must belong to the given account.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint, and openWorldHint, so the safety profile is covered. The description adds useful lifecycle context that media uploads are user-owned until registered, but it does not elaborate on response statuses or registration 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 short sentences, front-loaded with the core action and followed by the ownership/registration context. There is no filler or redundancy.

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

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

The tool is simple, annotations cover safety, schema coverage is complete, and an output schema exists, so return values need not be explained. The remaining gap is explicit routing to sibling media-library tools, which the description implies rather than states.

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 account_id and media_id are already documented with patterns and meaning. The description reinforces the account/user ownership context but does not add parameter syntax or constraints 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 states a specific verb and resource: read the processing status of an upload. It also scopes the resource as owned by the connected X user until registered in the account's media library, which helps distinguish it from media-library item tools, though no sibling is named explicitly.

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

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

Usage is implied by the ownership and pre-registration context: this is for checking an upload owned by the connected user before it is registered in an account's media library. However, the description does not explicitly say when to use this versus list_media_library or get_media_library_item.

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

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

Annotations already carry the safety profile (readOnly, idempotent, non-destructive, openWorld), so the bar is lower. The description still adds real context beyond them: native X fields and pagination are preserved, and monetary values ending in _micro are in millionths of the account currency — a convention an agent could easily misread without this note.

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 compact clauses with no filler, and the core operation is front-loaded before the field/unit notes. The second clause is slightly run-on but every part 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?

An output schema exists, so return structure needn't be restated, and full param coverage in the schema covers the inputs. What remains is well served by the field-preservation and currency-unit notes; only an explicit pointer to the list sibling is missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds the _micro monetary-unit convention that appears nowhere in the schema and shapes how the agent interprets results. It does not, however, clarify the with_deleted parameter's behavioral effect beyond what the schema already says.

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 ('Get a single promoted post by ID'), and the word 'single' implicitly distinguishes it from the x_ads_list_promoted_posts sibling. It stops short of naming the sibling or the list/get boundary explicitly, so it's clear but not fully differentiated.

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?

'By ID' implies you should call this only when you already hold a promoted_tweet_id rather than enumerating, which is useful implied routing. There is no explicit when-to-use/when-not statement and no alternative tool is 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?

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds two useful traits beyond that — native X field preservation and the _micro monetary unit convention — but the 'pagination preserved' note is confusing for a single-record get and no auth or soft-delete behavior is mentioned.

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?

Very short and front-loaded with the core action. The second clause is jammed on without punctuation and mixes two unrelated facts (field preservation, monetary units), which slightly hurts readability.

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

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

With an output schema, full parameter coverage and complete annotations, the description only needs to orient the agent, and it does. The only real gap is the absence of any soft-delete or usage context around with_deleted.

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 account_id, targeting_criterion_id, lang and with_deleted are already fully documented in the schema. The description adds no parameter-level meaning beyond the schema, which is the baseline-3 case.

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

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

States a specific verb and resource ('Get a single targeting criterion by ID'), which implicitly distinguishes it from the sibling x_ads_list_targeting_criteria by returning one record. It does not explicitly name that sibling, so the differentiation is inferred 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?

Usage is only implied by 'single ... by ID' versus the list sibling; there is no explicit when-to-use, when-not-to-use, or alternative named. An agent can infer the routing but must do the work itself.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description's added value is the native-field/pagination preservation note and the _micro currency convention. That is genuine behavioral context beyond structured fields, though the _micro note is boilerplate that does not apply to any field visible in this 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?

It is short, but the two clauses run together without punctuation ('tag by ID Native X fields...'), which slightly obscures the intended reading. The core purpose is still front-loaded, so the cost is minor polish rather than wasted 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?

With an output schema present, return values needn't be explained, and the soft-delete parameter is fully described in the schema. The only missing element an agent might want is how to discover a valid web_event_tag_id, which is a small gap for a simple read-by-ID tool.

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

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

Schema description coverage is 100%, so all three parameters (account_id, web_event_tag_id, with_deleted) are already documented in the schema. The description adds nothing param-specific beyond the ID-based lookup already implied by the name, 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 and resource ('Get a single website conversion event tag by ID'), which is distinguishable from the sibling list tool x_ads_list_web_event_tags by the singular-by-ID framing. It doesn't name the sibling explicitly, so differentiation depends on the reader inferring it from the tool names.

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 'by ID' phrasing implies you call this when you already hold a web_event_tag_id, but there is no explicit when-to-use/when-not guidance and no reference to x_ads_list_web_event_tags as the way to obtain IDs. Usage is inferable but not stated.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds that native X fields and pagination are preserved and that _micro monetary fields are millionths of the account currency, which is genuine context beyond the annotations, though the currency note looks like family-wide boilerplate for a post-listing endpoint. It says nothing about rate limits or result caps.

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 purpose front-loaded, which is good. However, the second sentence is a run-on missing punctuation ("account Native X fields...") and reads like appended boilerplate rather than tool-specific guidance.

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

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

With an output schema present, return values needn't be explained, and annotations cover safety. What is missing is disambiguation from x_ads_list_promoted_posts and an explanation of the NULLCAST default interaction with 'usable for promotion', which materially affects results for a 9-parameter listing tool.

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

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

Schema coverage is 100%, so all nine parameters are documented in the schema itself, and the two enums (tweet_type, timeline_type) carry their own value descriptions. The description adds no parameter-level meaning beyond the _micro convention, 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 and resource ("List posts (tweets)") plus a scope qualifier ("usable for promotion by an ads account"), so the operation is unambiguous. It does not, however, distinguish itself from close siblings such as x_ads_list_promoted_posts or x_ads_list_post_previews, leaving the agent to 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?

The description never says when to choose this over the many other list_* siblings, nor does it state prerequisites (account permissions, why tweet_type is mandatory). There are no exclusions or alternative-naming beyond the implicit 'promotable' framing.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive, so the safety profile is covered. The description still adds genuinely useful behavioral context beyond them: native X fields and pagination are preserved, and monetary values ending in _micro are millionths of the currency unit.

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 filler. Minor flaw: the missing sentence break between 'access' and 'Native X fields' makes the second clause read as a run-on.

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

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

With an output schema present, return values need not be explained, and the annotations cover the safety profile. For a single-optional-param read tool, purpose plus the _micro and pagination notes are all an agent needs to call it correctly.

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

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

Schema description coverage is 100% and the single account_ids parameter is fully documented in the schema, so the baseline is 3. The description adds no additional detail on the filter parameter itself.

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

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

Specific verb+resource: 'List the ads accounts the authenticated user can access'. It is clearly distinguished by resource from siblings like x_ads_list_campaigns or x_ads_list_funding_instruments, though it never explicitly positions itself relative to them.

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

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

No when-to-use guidance, no prerequisites, and no mention of alternatives. It does not say, for example, that this should be called first to obtain account IDs needed by the other ads tools, nor when to pass account_ids vs omit it.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the description's added value is the data conventions: native X fields are preserved and monetary values ending in _micro are millionths of the account currency. That is genuinely useful domain context an agent cannot get from the schema or annotations. It omits any note on default exclusions (drafts/deleted) or paging behavior, which would have raised it further.

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?

Very short and front-loaded with purpose before the field-convention details. The second clause is slightly run-on and mis-punctuated ('account Native X fields'), but every sentence 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?

With 10 fully documented parameters, an output schema handling return values, and annotations covering the safety profile, the description only needs to supply purpose and data conventions, which it does. Missing only cross-references to sibling tools and defaults for draft/deleted inclusion.

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 every one of the 10 parameters is documented in the input schema (cursor, count, sort_by, with_deleted, etc.), so the description carries no parameter burden. It adds nothing parameter-specific, which is the expected baseline 3 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?

States a specific verb and resource ('List campaigns') scoped to an account, which distinguishes it from x_ads_get_campaign (single campaign) and the nested list tools like x_ads_list_line_items. It stops short of naming any sibling or the relationship between campaigns and line items, so differentiation is inferable rather than explicit.

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

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

There is no guidance on when to use this list endpoint versus x_ads_get_campaign or the line-item/promoted-post listings, and no mention of prerequisites such as obtaining an account_id or when filtered variants (with_deleted, with_draft, campaign_ids) should be applied. Usage is only implied by the tool name and 'for an account'.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered; the description adds real value beyond that by disclosing that native X field names are preserved and that _micro monetary fields are millionths of the account currency, which an agent would otherwise misread. It stops short of describing default result set size or what the response envelope looks like, but an output schema exists.

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 clauses with no padding and the core purpose front-loaded. The second clause runs on without a separator ('account Native X fields'), which slightly harms readability but not 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?

With an output schema and full annotations, most structural burden is carried elsewhere, and the currency-unit note is a genuinely useful addition. However, for an 11-parameter list tool with soft-delete and legacy-card flags, the description never acknowledges that the result set is filtered/opt-in by default, leaving an agent to discover behavior from the schema 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 all eleven parameters are already documented in the schema, making 3 the baseline. The description only reinforces pagination and currency units, adding no semantics for q, sort_by, card_ids, with_deleted, or the exclusivity of with_total_count with cursor.

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 ('List the cards in an ads account'), which clearly distinguishes it from the sibling get_card (single card) at the verb level. It does not, however, explicitly route against other list siblings like x_ads_list_media_library, so the differentiation is only 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?

No sentence says when to use this instead of x_ads_get_card or the other list tools, and no prerequisites or exclusions are given. The only usage-adjacent hint is that pagination is preserved, which an agent could infer implies cursor-based traversal, but it is not framed as 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?

Annotations already establish readOnly/idempotent/non-destructive, so the description correctly spends its words elsewhere: it discloses that native X fields and pagination metadata are preserved and that '_micro' monetary fields are millionths of the account currency — a non-obvious unit convention an agent cannot infer from annotations or 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?

A single compact statement with the purpose front-loaded and no filler. It is slightly dense — two distinct ideas run together without punctuation — but nothing is wasted.

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

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

An output schema exists and parameters are fully documented, so the description only needs to add the domain-specific quirks, which it does (payment-source semantics, native field preservation, micro-unit currency). A brief note on paginating via cursor or when to set with_deleted would make it complete.

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

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

Schema description coverage is 100% and every parameter (count, cursor, sort_by, with_deleted, with_total_count, funding_instrument_ids) is documented there, so the description adds no parameter meaning of its own. 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 ('List funding instruments (payment sources) for an ads account') and parenthetically clarifies the domain term. No sibling tool covers funding instruments, so differentiation is not required, though it does not explicitly say so.

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

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

There is no when-to-use guidance, no mention of the account-scoping prerequisite beyond the 'for an ads account' phrase, and no indication of when to use the filters (with_deleted, funding_instrument_ids) versus listing everything. Usage is only implied by the tool's name and purpose.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so safety is covered. The description adds genuinely useful context beyond that: native X fields and pagination are preserved, and _micro monetary fields are millionths of the account currency. It does not describe ordering or result size limits.

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

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

The text is short but poorly structured: a missing period/separator after 'product type' merges the purpose with the field-convention note into one run-on sentence. Front-loading is fine, but the second clause is jammed in without punctuation.

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

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

An output schema exists so return values needn't be explained, and annotations cover the safety profile. However, the description never clarifies how placements relate to a specific line item id — which an agent will wonder about given the 'per line item' phrasing — leaving a real gap for a tool with only one enum parameter.

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

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

Schema coverage is 100% and the product_type enum already documents the restriction. The description echoes the parameter's role ('per line item product type') but adds no syntax or default behavior 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 ('List valid placement combinations') scoped 'per line item product type', which distinguishes it from the sibling list/get tools. The purpose is identifiable, though 'combinations' of what (placements) and the relationship to line items remains slightly fuzzy.

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 call this versus e.g. x_ads_list_targeting_criteria or x_ads_get_line_item, and no indication that the single parameter is optional or what happens when it is omitted. The agent must infer the usage context 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?

Annotations already declare readOnly/idempotent/non-destructive, so the description's job is lighter. It adds two genuinely useful facts not in the structured fields: that native X fields and pagination are passed through unchanged, and that _micro monetary fields are millionths of the account currency — a real interpretation hazard.

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, purpose first, with the money-format caveat following. Slightly run-on due to the missing sentence break between 'account' and 'Native X fields', but nothing is wasted.

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

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

With a full output schema and complete annotation coverage, the description only needs to orient the agent. It does so, including the currency-unit caveat and pagination behavior; the main omission is routing guidance relative to sibling list/get tools.

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

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

Schema description coverage is 100%, so all 11 parameters (including with_deleted, with_total_count exclusion with cursor, and the 200-ID limits) are already documented. The description adds no parameter-level meaning 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 (List) and resource (line items / ad groups) scoped to an ads account, which separates it cleanly from x_ads_get_line_item. It does not explicitly contrast with x_ads_list_campaigns or x_ads_list_line_item_placements, but the resource noun 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?

There is no statement of when to call this versus x_ads_get_line_item (single record), x_ads_list_campaigns, or the placements sibling, and no prerequisites or exclusions. The agent must infer usage purely from the name.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description adds two useful semantic notes — that native X field names and pagination are preserved, and that _micro fields are millionths of the account currency — but does not mention pagination limits, empty-result behavior, or rate limits beyond what the schema implies.

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

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

It is short and front-loaded, but the two clauses are run together without punctuation ('...in an ads account Native X fields and pagination are preserved'), which forces a second read to parse. The _micro convention note is generic boilerplate rather than media-library-specific.

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

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

With an output schema present, complete parameter documentation in the schema, and annotations carrying the safety profile, the description covers what remains necessary. Only the sibling disambiguation and pagination behavior are missing, and those are modest gaps for a straightforward list operation.

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

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

Schema description coverage is 100%, so q, count, cursor, account_id and media_type are all documented in the schema. The description adds no parameter-level detail beyond that, which is the expected baseline when the schema does the heavy lifting.

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: 'List the media library objects in an ads account'. This clearly distinguishes it from x_ads_get_media_library_item (single-item retrieval) and from other list siblings by resource type, though it does not name an alternative 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 indication of when to use this versus x_ads_get_media_library_item, x_ads_get_media_upload_status, or x_ads_list_account_posts. The agent must infer selection purely 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?

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description adds genuinely useful context that monetary fields suffixed _micro are millionths of the account currency and that native X fields and pagination are preserved — but it omits the 200-ID cap and the DRAFT case, both of which affect correct invocation.

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?

Appropriately short, and the purpose is front-loaded. But the second clause runs on without punctuation and reads as a spliced fragment ('...scheduled posts Native X fields and pagination are preserved'), forcing a re-read.

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

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

An output schema exists, so return values need not be explained, and the description covers the one non-obvious output convention (_micro currency units). The main gap is that the stated scope ('published or scheduled') fails to mention the DRAFT option the required tweet_type parameter supports.

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%, including the tweet_type enum, the 200 max on tweet_ids, and the user_id default, so the schema already carries parameter meaning. The description's only param-adjacent contribution is the _micro convention, which concerns returned values rather than inputs — 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 ('Get rendered HTML previews for ... posts'), which distinguishes it from the sibling list/get post tools that return post data rather than rendered previews. However, it says 'published or scheduled' while the required tweet_type enum also accepts DRAFT, so the stated scope is narrower than the tool's actual capability.

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 choose this over x_ads_list_promoted_posts, x_ads_get_promoted_post, or x_ads_list_account_posts, and no prerequisites stated. The agent must infer the preview-vs-metadata distinction entirely from the tool name and one-line purpose.

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

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

Annotations already declare readOnly, idempotent, non-destructive behavior, so the safety profile is covered. The description adds genuinely useful context beyond that: returned objects keep native X field names and pagination semantics, and monetary fields ending in _micro are in millionths of the account currency — a non-obvious unit convention an agent could easily misread.

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 followed by return-value semantics. Minor flaw: the second clause runs together without clear punctuation ('for an ads account Native X fields...'), which slightly hurts readability but wastes no 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?

An output schema exists, so return values needn't be explained, and annotations cover the safety profile; the description's currency-unit and native-field notes fill the remaining gap. What is missing is any hint about how the filters interact (e.g., with_total_count being exclusive with cursor is only in the 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%, so all 8 parameters (count, cursor, sort_by, account_id, with_deleted, with_total_count, line_item_ids, promoted_tweet_ids) are already documented in the schema. The description adds no parameter-level detail, 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 and resource ('List promoted posts (promoted tweets) for an ads account'), which clearly separates it from the singular x_ads_get_promoted_post sibling by name alone. It does not, however, explicitly contrast itself with other list endpoints such as x_ads_list_account_posts, leaving the agent to infer the distinction.

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 when-to-use guidance, no mention of filtering by line_item_ids or promoted_tweet_ids, and no note on when to prefer this over x_ads_list_account_posts or x_ads_get_promoted_post. All scoping behavior is left entirely to the schema.

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

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

Annotations already declare readOnly/is idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful domain context not in the annotations: native X fields and pagination are preserved in output, and _micro monetary fields are millionths of the account currency — an important unit caveat for interpreting numbers.

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 compact sentences with the core purpose front-loaded and no wasted text. Minor deduction for the awkward, punctuation-free run-on 'line items Native X fields...' which slightly obscures the sentence boundary.

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

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

With an output schema present and 100% parameter documentation, the description need not explain returns; it correctly supplements with the _micro unit convention and pagination-preservation note. The only real gap is the absence of routing guidance to sibling targeting tools.

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

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

Schema coverage is 100% across all 9 params, including cursor, count, sort_by, with_deleted, with_total_count and targeting_criterion_ids, so the schema carries the semantic load. The description only touches the monetary-unit convention and does not add parameter-level meaning, making the baseline 3 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?

States a specific verb+resource ('List targeting criteria') scoped to an ads account's line items, which distinguishes it from the singular x_ads_get_targeting_criterion sibling. It does not explicitly contrast with x_ads_search_targeting_interests or x_ads_search_targeting_locations, but the account/line-item framing makes the correct pick inferable.

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 requirement that criteria be scoped by line_item_ids is visible in the schema, so usage is implied, but the description itself gives no when/when-not guidance and never names alternatives (e.g., fetching a single criterion with x_ads_get_targeting_criterion, or searching interests/locations).

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 readOnlyHint and idempotentHint already declared, the description adds real context beyond annotations: that native X fields and pagination are preserved, and that monetary fields ending in _micro are millionths of the account currency. It doesn't mention soft-deleted record behavior despite a with_deleted param, which is a minor 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 dense but front-loaded sentence with the resource definition first and behavioral notes after. Every clause carries information, though the semicolon-chained style makes it slightly harder to scan.

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

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

An output schema exists, so return values needn't be explained, and the schema fully covers the 7 parameters. The description supplies the unit convention and pagination note an agent needs; only the soft-delete/filtering semantics are left to the 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 all 7 parameters are already documented in the schema, including count, cursor, sort_by and web_event_tag_ids. The description adds no parameter-level detail beyond a generic mention that pagination is preserved, 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: 'List the website conversion event tags (pixels) in an ads account.' It also explains what a tag id is for, which distinguishes this list tool from the sibling getter x_ads_get_web_event_tag only implicitly (via 'list' vs 'get'), so full sibling differentiation isn't spelled out.

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

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

Useful context is given — 'a tag's id is what a conversion line item takes as its primary_web_event_tag' — implying you call this before creating line items. But there is no explicit when-to-use vs x_ads_get_web_event_tag, and no exclusions or prerequisites stated.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds that native X fields and pagination are preserved, which is genuine context, but the trailing _micro monetary note is boilerplate irrelevant to interest categories and adds noise rather than insight.

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

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

Three compact sentences with the core purpose and the downstream dependency front-loaded. The final _micro sentence is dead weight for a non-monetary tool and slightly dilutes the otherwise tight structure.

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

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

An output schema exists so return values need no explanation, and all three parameters are documented in the schema. Pagination is acknowledged and the primary consumer (add_targeting_criterion) is named, leaving only minor gaps such as expected result volume or ordering.

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% – q, count and cursor are all documented in the schema, including the "omit to list unfiltered" behavior. The description only echoes that search is by name, so it adds little beyond what the schema already 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 and resource ("search targetable interest categories") and clarifies the search dimension ("by name"), which cleanly separates it from the sibling x_ads_search_targeting_locations. An agent can tell what it returns without opening the schema.

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

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

Explicitly names the downstream use case: finding targeting_value IDs needed by add_targeting_criterion for INTEREST-type criteria. It lacks an explicit when-not statement (e.g., use the locations variant for geo targeting), but the domain is narrow enough that the routing is clear.

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

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

Annotations already establish readOnly, idempotent, non-destructive, open-world semantics, so the bar is lower. The description still adds useful behavior: responses preserve native X fields and pagination, which tells the agent to expect upstream-shaped objects and cursor paging.

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

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

Three short sentences, front-loaded with the purpose and then the workflow link. The trailing note on _micro monetary fields is generic boilerplate for a location lookup and is the one sentence that does not fully earn its place.

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

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

With an output schema present and full parameter documentation, the description needs only to orient the agent, which it does: purpose, workflow hook, and paging note. A note on omitted-q behavior (list all locations) would complete it.

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

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

Schema description coverage is 100% and the enum for location_type is fully documented, so the schema does the heavy lifting. The description mentions pagination existing but adds no semantics for q, country_code, or location_type beyond what is already structured.

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 ('Search targetable locations by name') and clearly implies a location catalog rather than the interest catalog used by sibling x_ads_search_targeting_interests. It does not explicitly name that sibling, but the resource distinction 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?

Gives a concrete downstream use: find targeting_value IDs required by add_targeting_criterion for LOCATION-type criteria. That is a real when-to-use condition. It does not state when-not to use it or name the closest alternative (search_targeting_interests).

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