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 the pagination contract (next_cursor) and that native configuration is retained, but says nothing about result ordering, rate limits, or empty-result 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 scope. The ad squad glossary sentence is somewhat tangential to listing ads but is brief enough not to distract.

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 rich annotations, the definition covers the essentials for calling the tool. However, it omits any routing guidance relative to the many sibling listing tools, which is the main gap for a read-only list endpoint in a crowded toolset.

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

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

Schema coverage is 100%, with limit, cursor, and adAccountId all described in the schema itself. The description's mention of next_cursor restates what the schema already conveys, so no meaningful semantics are added beyond the structured fields.

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

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

States a specific verb and resource ('List Snapchat ads in the selected account') and adds a clarification that an ad squad maps to an ad group/ad set, which helps separate ads from adsquads. It stops short of explicitly distinguishing itself from siblings like snapchat_get_adsquads or snapchat_list_ad_creatives.

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

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

Usage is only implied by 'List ... in the selected account'; there is no explicit when-to-use or when-not-to-use guidance, nor a named alternative for related entity types such as ad squads or 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?

While annotations already confirm it is a read-only operation, the description adds valuable behavioral context by stating it retains 'full native configuration' and explicitly details the pagination mechanism using 'next_cursor'.

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 highly concise. The two sentences efficiently convey the tool's purpose and the specific definition of the entity it manages.

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

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

The description is complete for a read-only listing tool, defining the scope and noting the pagination mechanism, which is essential for retrieving all data.

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?

Since the schema description coverage is 100%, the description primarily focuses on definition and scope rather than filling gaps. It adds minor semantic value by explaining the role of the cursor in managing the full list.

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

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

The description clearly states that the tool lists Snapchat adsquads and provides a helpful definition of an ad squad as an ad group or ad set. It is specific to the entity type, though it does not explicitly distinguish itself from similar listing tools.

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

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

The description does not provide guidance on when to use this tool versus alternatives. The agent must infer that this is for ad group/set listings based on the naming, without explicit comparison to other sibling tools.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered elsewhere. The description usefully adds that results retain native configuration and are paginated via next_cursor, but it doesn't note ordering, result caps, or rate-limit behavior beyond what the schema conveys.

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 purpose and pagination behavior front-loaded. The ad-squad clarification is slightly tangential but is short and aids disambiguation, so it earns its place.

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

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

With an output schema present and 100% schema coverage, the description doesn't need to explain return values. It covers purpose, scope, and pagination, leaving only minor gaps like ordering and result-size expectations.

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 limit, cursor, and adAccountId are already fully documented in the schema. The description only echoes next_cursor as the pagination token; it adds no syntax or constraint detail beyond the structured fields, 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 Snapchat campaigns') plus the scope ('in the selected account'), which lets an agent distinguish it from snapchat_get_adsquads or snapchat_get_ads by entity type. The ad-squad clarification reinforces the campaign/adgroup distinction, though it doesn't explicitly name the sibling tools.

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

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

Usage is only implied: 'in the selected account' hints at the adAccountId scope, and the ad-squad note implies when to pick campaigns over adsquads. There is no explicit when-to-use/when-not statement or named alternative for hierarchy traversal.

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 behavior, so safety is covered. The description adds real value by saying results retain "full native configuration" (unmodified payload) and that pagination works via next_cursor, but it says nothing about ordering, page-size effects, or whether child elements are expanded.

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 first sentence is dense and front-loaded, covering scope, payload fidelity, and pagination efficiently. The second sentence ("An ad squad is an ad group/ad set") is unrelated to this tool's operation and dilutes focus without earning 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, the description needn't explain return values, and it does cover the pagination contract and payload fidelity. However, for a list tool sitting alongside several similar creative/media listers, the missing differentiation and any hint about element types leaves the definition only minimally complete.

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

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

Schema description coverage is 100%, so limit, cursor, and adAccountId are already fully documented, making baseline 3 appropriate. The description only reinforces the next_cursor pagination loop, adding no format or constraint information 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?

It states a verb and resource ("List Snapchat creative elements") scoped to an account, but it never clarifies what a "creative element" is relative to the sibling tools snapchat_get_creatives, snapchat_list_ad_creatives, or snapchat_get_media. The trailing note about ad squads hints at the data model rather than the tool's own scope, so an agent cannot confidently tell this apart from its closest 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?

There is no when-to-use guidance at all: no mention of when to pick this over snapchat_get_creatives or snapchat_list_ad_creatives, and no prerequisites beyond the required adAccountId already in the schema. The only implicit hint is that it is paginated, which does not route the agent between alternatives.

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

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

Annotations already declare readOnly, idempotent, non-destructive, so the safety profile is covered. The description adds meaningful behavior beyond that: results retain full native configuration rather than a normalized subset, and pagination flows through next_cursor.

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 filler. The trailing glossary sentence is slightly tangential but earns its place as domain clarification.

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, rich annotations, and fully described parameters, the remaining burden is disambiguation from the near-identical sibling lister, which the description does not address. Otherwise adequate for a simple read-only list 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 are already documented, including the cursor/next_cursor flow. The description's mention of pagination and next_cursor reinforces but does not extend 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 clear verb+resource ('List Snapchat creatives') scoped to the selected account, and notes it returns full native configuration. However, it never distinguishes itself from the very similar sibling 'snapchat_list_ad_creatives', leaving the agent to guess which lister to use.

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 instead of snapchat_list_ad_creatives, or whether it should be called before snapchat_get_creative_elements. The second sentence only defines 'ad squad' terminology, not usage 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?

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description adds genuinely new behavioral context with 'verified account ownership', telling the agent that a cross-account or unauthorized entity will fail rather than return data. It does not describe not-found or error semantics, but the addition is meaningful.

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?

One sentence, front-loaded with the verb, and no filler. It loses a point only because the entity enumeration largely duplicates the kind enum already in 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?

With an output schema present and annotations covering safety, the description needs only to state the operation and access requirement, which it does. The main residual gap is that entity-type-specific nuances (e.g., that lead forms or segments may need different identifiers) are left entirely 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 description coverage is 100%, and the schema itself documents the kind enum, the dual-format entityId (UUID or numeric audience-segment ID), and the adAccountId constraint. The description restates the entity list but adds nothing on format or edge cases, 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 verb 'Read' plus an explicit enumeration of entity types ('campaign, ad squad, ad, creative, media, segment...') makes clear this is a single-entity fetch keyed by kind. It is distinguishable from the sibling list tools (snapchat_get_campaigns, snapchat_get_ads, etc.) only by the singular phrasing, not by any explicit contrast.

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 generic getter versus the type-specific siblings, and no mention of prerequisites such as when an entityId is known. The only usage signal is the implicit singular/plural distinction, which the agent must infer.

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

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

Annotations already cover readOnly/idempotent/non-destructive/openWorld, and the description adds genuinely new behavioral facts: spend and conversion values are micro-currency, empty test-account rows are not live evidence, and partial:true signals pagination. These are exactly the traps an agent would otherwise 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?

Four tight sentences, zero filler, with the core action and interval semantics front-loaded ahead of the caveats. Dense but every clause adds usable 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 9-parameter reporting tool with an output schema, the description covers the high-risk semantics (exclusive end, micro currency, partial paging, test-account emptiness) that the schema cannot express. The remaining parameter distinctions live in the schema, so nothing critical 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 coverage is 100%, so baseline is 3, but the description adds real semantics beyond it: the interval end is exclusive and monetary fields are micro-currency, both of which change how the agent interprets results. It doesn't disambiguate breakdown vs reportDimension, which the schema handles.

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 ('Read native Snapchat stats') plus the interval/granularity/breakdown shaping, which clearly separates it from the entity-listing siblings like snapchat_get_campaigns and snapchat_get_ads. It doesn't explicitly name a sibling to defer to, keeping it just below 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 by 'native Snapchat stats' – the agent can infer this is the reporting/metrics tool versus the entity fetchers, but there is no explicit when-to-use or when-not guidance or named alternative. The caveats about test-account emptiness and paging are behavioral notes rather than selection guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true. The description adds useful behavioral context by noting that native configuration is retained and pagination uses next_cursor, though it does not mention auth or rate-limit 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 short and front-loaded with the main purpose. The second sentence about ad squads is brief but only loosely connected to interaction zones, so it is not pure waste but slightly tangential.

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

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

For a simple list tool with fully described parameters, rich annotations, and an output schema, the description covers account scope and pagination adequately. It does not define what an interaction zone is, but the output schema can carry return-value detail.

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 are already documented in the schema. The description only restates account scoping and pagination via next_cursor, adding no meaningful semantics beyond the schema 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 clearly states a specific verb and resource: "List Snapchat interaction zones" within the selected account. It does not differentiate this tool from sibling tools like snapchat_get_adsquads or snapchat_get_targeting, but the core action 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 gives no guidance on when to use this tool versus alternatives. It mentions account scoping and pagination, but does not state any conditions, exclusions, or sibling-tool comparisons that would help an agent choose correctly.

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 semantics, and the description adds real behavioral context: results are paginated via next_cursor and returned as raw native configuration rather than a normalized shape. That pass-through disclosure is valuable for an agent interpreting 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?

The first sentence is front-loaded and efficient. The second sentence about ad squads earns no place here since the tool takes no ad squad parameter, making it 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?

With full annotations, 100% schema coverage, and an output schema covering return values, the description supplies enough for correct invocation. Only the missing routing versus sibling list tools keeps it from full marks.

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 all three parameters thoroughly documented (limit bounds, opaque cursor from next_cursor, adAccountId format and provenance). The description only echoes next_cursor, adding nothing 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 (List) and resource (Snapchat lead generation forms) scoped to the selected account. The resource is distinct from siblings like snapchat_get_adsquads or snapchat_get_creatives, though it never explicitly contrasts itself with 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, prerequisite, or alternative guidance is given; the agent must infer usage from the name alone. The 'ad squad is an ad group/ad set' sentence is terminology trivia unrelated to this tool's parameters, so it does not function as usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds that results retain full native configuration and paginate via next_cursor, which is useful behavioral context, but it says nothing about rate limits, result shape, or what 'media' specifically contains beyond the output schema.

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

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

The core sentence is front-loaded and efficient, but the second sentence about ad squads is irrelevant to a media-listing tool and reads as copy-paste noise that does not 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?

An output schema exists and annotations cover safety, so the description needn't explain return values. However, for a tool in a dense sibling cluster, it fails to clarify how 'media' differs from creatives or media status, leaving a real selection gap.

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

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

Schema description coverage is 100%, so all three parameters are already documented, including the cursor's provenance from next_cursor. The description only restates pagination, adding no semantics beyond the schema, 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?

The description opens with a specific verb and resource ('List Snapchat media in the selected account'), which lets an agent identify the operation. It does not distinguish this from nearby siblings such as snapchat_get_media_status or snapchat_list_ad_creatives, and the trailing ad-squad sentence is unrelated to media and only muddies 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?

There is no explicit guidance on when to use this tool versus snapchat_get_media_status, snapchat_list_ad_creatives, or snapchat_get_creatives. The only implied usage is that an adAccountId is required, which the schema already states.

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 safety (readOnly, idempotent, non-destructive). The description adds the substantive behavioral fact that a returned ready:true gate is required before creative creation, which is policy context not in the annotations. It stops short of describing latency, quota, or error conditions.

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 read action and then the gating rule. No filler, and every clause carries decision-relevant 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 values need no explanation, and the description supplies both purpose and the gating rule. The only gap is the explicit relationship to snapchat_get_media, which an agent might otherwise confuse with this single-item status read.

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 UUID parameters are fully documented in the schema, including the note that mediaId comes from snapchat_create_media. The description adds no parameter-level meaning 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?

Specific verb (read) plus resource (account-owned media) plus an added dimension the sibling list tool likely lacks: native processing state. It implicitly differentiates from snapchat_get_media by focusing on a single item's processing state, 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?

Gives a concrete decision rule: only ready:true permits creative creation, and an accepted upload alone is insufficient. That tells the agent exactly when to call this before building creatives, but it doesn't name an alternative tool or state when not to call 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 destructiveHint=false, so the safety profile is covered elsewhere. The description adds useful workflow context (this is a prerequisite lookup for app-promotion/retargeting setup), but says nothing extra about scoping, result cardinality, or rate/auth behavior beyond the annotations.

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

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

One sentence, front-loaded with the verb and resource, with the timing rationale appended. Every clause carries information and there is no filler.

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

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

With an output schema handling return values, full schema coverage on the single parameter, and annotations covering safety, the description supplies the remaining piece an agent needs: what the tool retrieves and why/when to call it. Slightly more detail on result scope would make it fully self-sufficient, but nothing essential 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 coverage is 100% and the single adAccountId parameter is fully documented in the schema, including the warning that it is a Snapchat ad account UUID and not an organization ID. The description only echoes the 'selected ad account' framing, adding no format or constraint detail beyond the schema, 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?

The description gives a specific verb ('Read') and resource ('Snap App IDs associated with the selected ad account'), which is clearly distinct from the campaign, adsquad, creative, and targeting siblings. It stops short of explicitly contrasting with any named sibling, but the resource itself 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?

It states a concrete usage context: call this before creating app promotion campaigns or mobile retargeting audiences. That tells the agent when the tool is relevant, though it does not name alternatives or state exclusions (e.g., when another apps-related lookup should be used instead).

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=true, idempotentHint=true and destructiveHint=false, so safety is covered externally. The description adds only the sequencing rationale, saying nothing about whether all pixels are returned, whether an empty list is possible, or any account-permission requirements for an openWorld read.

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?

One short sentence, verb-first, with the usage precondition in the same clause. Nothing is padded or repeated from the title.

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 single-parameter read with an output schema and full annotation coverage, the description supplies enough to select and invoke correctly. The only minor gap is that it does not indicate whether the result set can be empty or how large it may be.

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 adAccountId parameter already documents UUID format and the 'never an organization ID' caveat. The description's 'associated with the selected account' adds no syntax or scoping detail 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 and resource ('Read the pixels') scoped to an account, which is clearly distinct from siblings like snapchat_get_segments or snapchat_get_mobile_apps. It does not explicitly name or rule out any sibling, but the resource noun alone is differentiating.

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 trigger: call it before configuring conversion optimization or website audiences. That is real usage context, though it states no exclusions or alternatives for cases where a different pixel/audience source might apply.

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 destructiveHint=false, so the safety profile is fully covered. The description adds the useful behavioral note that native configuration is retained and that responses paginate via next_cursor, but pagination is already spelled out in the schema's cursor/limit descriptions, so the marginal disclosure is modest.

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 the resource statement is front-loaded, which is good. However, the second sentence spends its words on an ad-squad definition that does not apply to segments, which is wasted and actively confusing rather than merely redundant.

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

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

An output schema exists and annotations are rich, so return values and safety need not be explained. The remaining incompleteness is conceptual: it never clarifies what a Snapchat 'segment' is (audience/targeting segment) versus an ad squad, which is the one thing an agent choosing among these siblings actually needs.

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%: adAccountId's UUID constraint and the cursor/limit semantics are fully documented in the schema. The description mentions pagination via next_cursor but adds no format, default, or edge-case meaning 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?

The first clause names a specific verb and resource ('List Snapchat segments in the selected account'), which is clear enough. But the trailing sentence 'An ad squad is an ad group/ad set' describes a different entity than segments and directly overlaps with the sibling snapchat_get_adsquads, muddying rather than sharpening differentiation.

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

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

Nothing states when to use this instead of siblings such as snapchat_get_adsquads, snapchat_get_targeting, or snapchat_get_entity. The only contextual cue is 'in the selected account', which is a scope statement, not usage guidance or an exclusion.

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 read-only, idempotent, non-destructive behavior, but the description adds meaningful context: the guide covers prerequisites and limitations, and it warns that documentation is not proof of account eligibility or live delivery. That caveat is useful behavioral guidance beyond the structured annotations.

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

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

The description is two compact sentences, front-loads the content scope, and adds the key caveat without waste. Every sentence contributes to understanding the tool's role.

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, no parameters, and rich annotations, the description supplies enough context to call the tool correctly. It could more explicitly frame whether the guide is static documentation versus account-specific advice, but the core guidance is complete.

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

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

The tool takes zero parameters, which matches the baseline of 4. The description appropriately does not introduce unnecessary parameter discussion, and no schema gaps need 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 uses a clear verb ('Read') and enumerates the guide's content domains: campaign objectives, audience workflows, creative prerequisites, and limitations. It distinguishes this documentation tool from the data-retrieval siblings, though it does not explicitly name an alternative tool.

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

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

It gives a narrow usage cue ('Use before claiming all features are available') and a caution about implementation not proving eligibility or delivery. However, it does not state when to prefer this guide over sibling tools or outline explicit exclusions.

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

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

Annotations already declare readOnlyHint/idempotentHint, so the safety profile is covered. The description goes beyond that by warning that absent fields do not imply broad targeting and that delivery breakdowns are not configuration — real semantic caveats an agent would otherwise get wrong. It stops short of saying what happens with an invalid or inaccessible adsquadId.

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 front-loaded and the two caveats after it. Every sentence carries distinct information; the only slight cost is that the caveats read as fragments without an explicit subject.

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 annotations covering safety/idempotency, a full schema, and an output schema, the remaining burden is purpose and interpretation — both handled. An agent can call this correctly and read the result skeptically without further guidance.

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 both UUID parameters carry their own descriptions (including the 'never an organization ID' warning for adAccountId). The description adds nothing parameter-specific, so the baseline 3 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?

Opens with a specific verb+resource ('Read configured ad squad targeting') and enumerates the returned facets: audiences, exclusions, demographics, geo, placements. The word 'configured' usefully separates it from sibling tools like snapchat_get_targeting_options and snapchat_get_targeting_specs, though those siblings are never 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?

The description gives interpretation guidance ('missing fields are unknown', 'breakdowns describe delivery') rather than selection guidance. It never says when to call this versus snapchat_get_targeting_options or snapchat_get_targeting_specs, so the agent must infer the boundary from the prompt's own 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds 'Retains pagination', but the cursor/limit parameters already encode that, so incremental value is limited. The 'do not invent category IDs' warning is the one genuinely additive behavioral signal.

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, front-loaded with the purpose and followed by the constraint. Nothing is redundant or padded.

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 rich schema, an output schema and full annotation coverage, the description only needs to convey intent and the ID-provenance rule, which it does. The partial category enumeration is the only gap, but it is corrected by the schema enum.

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 parameter is already documented in the schema, including the countryCode dependency for regions/metros/postal_codes. The description adds no format or constraint detail beyond that; its partial category list is slightly less complete than the schema enum.

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: 'Discover native targeting values', with an enumerated list of categories. It is clearly a read of a reference catalog, distinct from the entity-listing siblings, though it omits metros, postal_codes and age_groups that the schema supports, and does not explicitly distinguish itself from snapchat_get_targeting or snapchat_get_targeting_specs.

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?

'before editing' gives a timing cue and 'do not invent category IDs' implies these values are the sanctioned ID source, which is useful. However, there is no explicit comparison to the closely named siblings snapchat_get_targeting and snapchat_get_targeting_specs, so an agent must infer which tool to pick.

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 this as a safe, read-only, idempotent operation. The description adds useful behavioral context by noting that some targeting specs may be omitted from the ordinary ad squad response. It does not mention authentication requirements, rate limits, or pagination behavior beyond what the schema provides.

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 with no wasted language. The core purpose is front-loaded, and the follow-up sentence adds relevant context about why separate storage matters.

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, annotations fully cover safety semantics, and the input schema documents parameters. The description supplies the key missing context that large targeting specs may be omitted from ordinary responses. It is only slightly incomplete in not routing the agent among related 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 description coverage is 100%, so all four parameters are already documented in the input schema, including pagination and UUID requirements. The description adds no additional parameter-level 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 states a specific verb and resource: reading separately stored targeting specs. It also clarifies that these specs can include configurations exceeding 500 criteria and may be omitted from the ordinary ad squad response. It does not explicitly distinguish this tool from sibling targeting tools such as snapchat_get_targeting or snapchat_get_targeting_options.

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

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

The description implies when to use the tool: when targeting specs are stored separately or may be omitted from the ordinary ad squad response, especially for large configurations. However, it does not explicitly say when to choose this over sibling tools like snapchat_get_targeting, nor does it state exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful behavioral context beyond that: the returned schema is the server's *implemented* subset, not the full Snap API, which prevents an agent from assuming completeness.

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 the scope caveat immediately after. Nothing is redundant.

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

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

With an output schema available and a fully documented single enum parameter, the description need not explain return values. It covers purpose and the non-exhaustiveness caveat; the only small gap is the absence of an explicit 'call before create/edit' trigger.

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 single 'kind' parameter is already documented with an enum of nine entity types. The description adds no further meaning about how 'kind' affects the returned 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 states a specific verb ('Discover') and a specific resource (implemented write/creation fields, required fields, preview rules), which is clearly distinct from the sibling snapchat_get_* tools that fetch entity data. It does not name a sibling explicitly, but the resource boundary 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?

Usage is implied – an agent should call this before attempting to create or edit any of the listed entity kinds – but the description never says when to call it or what the alternative is. No 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?

Annotations already declare readOnly, idempotent and non-destructive, so the description rightly focuses on content: it enumerates what the read exposes (timezone, currency, test flag) and warns that test accounts cannot serve ads. That caveat is a genuinely useful behavioral detail beyond the annotations.

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

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

Two short sentences with zero filler; the 'what is read' clause comes first and the important test-account caveat second.

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

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

An output schema exists so return-value explanation is unnecessary, and the schema fully documents the single required parameter. Only the missing usage routing against sibling tools keeps it from being complete.

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

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

Schema coverage is 100% and the single adAccountId parameter is thoroughly documented in the schema (UUID format, listed in SNAPCHAT_ADS_ACCOUNT_IDS, not an organization ID). The description adds no parameter 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 (Read) and resource (the selected Snapchat ad account), plus the exact fields returned: permissions-visible metadata, timezone, currency and test flag. This is clearly distinct from the entity-fetching siblings, though it doesn't name them 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 statement of when to call this versus the many snapchat_get_* siblings, and no prerequisites. The only usage-adjacent sentence ('Test accounts cannot serve ads') is a caveat about interpreting the flag, not guidance for selecting the 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?

The annotations already cover the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely non-structured context: media URLs are short-lived Snap links, the server does not download them, and incomplete formats are flagged rather than silently dropped. The 'no performance is inferred' exclusion also prevents a common misreading. Missing only rate/pagination behaviour.

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 verb and resource, then the caveats in descending importance (incomplete data, no performance, expiring URLs). Every clause carries information an agent could otherwise get wrong.

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 the description need not explain return shape, and it correctly spends its words on the non-obvious traits: expiring URLs and partial-format reporting. It is nearly complete, though a note on how the limit/adIds interplay affects result volume would close the last gap.

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

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

Schema description coverage is 100%, so adIds, limit and adAccountId are fully documented upstream, including the 'omit adIds to resolve the first ads' fallback and the limit bounds. The description adds no parameter semantics of its own, 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?

Specific verb ('Resolve') plus a precise resource set: ad-linked images/videos, Story children and Collection tiles, with the returned fields named (business names, native IDs, fresh media URLs). An agent understands the operation without opening the schema. It stops short of 5 because it never names the adjacent siblings (snapchat_get_creatives, snapchat_get_media) that an agent must choose between.

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: 'Resolve ad-linked' suggests it is the creative-resolution path for ads, and 'Incomplete formats/media are reported' hints at error-tolerant behaviour. There is no statement of when to prefer this over snapchat_get_creatives or snapchat_get_media, nor any prerequisite or exclusion.

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