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

Annotations already declare readOnly, idempotent, non-destructive, open-world, so the safety profile is covered. The description adds that results are paginated via next_cursor and that entities keep their full native configuration, which is useful context, but it stops short of anything about ordering, page exhaustion, or error behavior on an invalid adAccountId.

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 front-loaded, no filler. The terminology sentence is short and does real work by disambiguating ad squad vs ad, though it could have been folded into a routing hint instead.

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 schema documentation, the description doesn't need to explain returns or parameters; it covers purpose, scope, and pagination adequately for a simple list tool. The remaining gap is sibling routing among the many snapchat_get_* list 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%: limit bounds, cursor opacity, and the adAccountId UUID-vs-organization-ID warning are all documented in the schema. The description only echoes the next_cursor concept and adds no new parameter meaning, 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 ads") plus scope ("in the selected account"), which separates it from siblings like snapchat_get_adsquads and snapchat_get_creatives. The closing line defining an ad squad as an ad group/ad set reinforces the ads-vs-adsquads boundary, though it never names the sibling tool to use for ad groups.

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 Snapchat ads in the selected account" — an agent can infer this is the read path for ads, but the description gives no explicit when-to-use, when-not-to-use, or alternative (e.g., use snapchat_get_adsquads for the parent ad groups) despite 20 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 readOnly, idempotent and non-destructive, so the safety profile is covered. The description still adds real context: results paginate via next_cursor and are returned with 'full native configuration', telling the agent to expect raw upstream-shaped payloads rather than a normalized projection.

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 action and scope; the second sentence exists solely to define the business term 'adsquad'. Nothing is wasted and nothing essential is buried.

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-value detail needn't be in the description, and read-only behavior is covered by annotations. The description supplies the entity definition and pagination model, which is sufficient for correct invocation; only sibling routing is left open.

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

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

Schema description coverage is 100% and all three parameters are documented inline, including cursor provenance and the adAccountId UUID constraint. The description only echoes cursor/account scoping, adding no format or edge-case detail 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 Snapchat adsquads') scoped to 'the selected account', and disambiguates the terminology by equating an ad squad with an ad group/ad set. It does not explicitly distinguish itself from sibling list tools like snapchat_get_campaigns or snapchat_get_ads, leaving hierarchy to inference.

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 'in the selected account' and by the pagination note, but there is no explicit when-to-use/when-not or named alternative among the many sibling get_* list tools. An agent can infer the context but must decide on its own between this and snapchat_get_campaigns/snapchat_get_ads.

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 declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds one genuine behavioral fact, that results retain full native configuration rather than a normalized shape; the pagination mention largely restates the cursor/next_cursor contract already in the schema, and nothing is said about ordering 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 with the core action and scope front-loaded and no filler. The ad-squad taxonomy sentence is slightly tangential to listing campaigns but does earn some place as a hierarchy hint.

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 explain return values, and it correctly focuses on scope and data fidelity. It would be stronger if it positioned the tool relative to the adsquad and ad listing tools in the same hierarchy.

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

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

Schema description coverage is 100% and all three parameters carry their own descriptions, including the adAccountId UUID warning and the opaque-cursor note. The description mentions next_cursor but adds no syntax, format or default information beyond what the schema provides, 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 gives a specific verb and resource ("List Snapchat campaigns") plus a scope ("in the selected account"), which clearly distinguishes it from the ad-squad and ad siblings. The second sentence about ad squads implies campaigns sit above ad squads in the hierarchy, but it never names snapchat_get_adsquads or snapchat_get_ads explicitly, so 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 the phrase "in the selected account" and by the requirement for an adAccountId. The description never states when to choose this tool over snapchat_get_adsquads or snapchat_get_ads, nor does it give any exclusion or prerequisite guidance beyond what the schema already enforces.

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. The description adds pagination context (next_cursor) and the claim of retaining "full native configuration," but says nothing about result size, field shape, or error conditions. The ad-squad sentence adds no behavioral insight about this tool.

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

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

It is short, but the second sentence defining an ad squad is off-topic for a creative-elements listing tool and consumes 40% of the text with misinformation-adjacent content. The genuinely useful part (pagination retention) is buried after an undefined resource name.

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

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

An output schema exists, so return values need not be explained. However, for a tool in a crowded sibling set with three similarly named creative/media listing tools, the description leaves the agent unable to determine which one returns what.

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 (limit, cursor, adAccountId) are already documented in the schema; baseline 3 applies. The description's mention of next_cursor only restates what the cursor schema field 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?

"List Snapchat creative elements in the selected account" gives a verb and a resource, but "creative elements" is never defined and is not distinguished from the close siblings snapchat_get_creatives and snapchat_list_ad_creatives. The trailing sentence defining an ad squad appears copied from an adsquad tool and muddies what this tool actually returns.

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 snapchat_get_creatives, snapchat_list_ad_creatives, or snapchat_get_adsquads, despite those being the obvious decision points. No prerequisites or exclusions are given.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile needs no restating. The description does add genuine context: results are page-based with a next_cursor, and records are returned in full native configuration rather than normalized. It stops short of saying anything about the account-level scope enforcement or ordering, so a 3 fits.

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 capability and pagination contract front-loaded; nothing is padded. The ad-squad glossary sentence is the one weak element — it earns little place in a creatives listing definition.

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 plus full schema coverage, the description carries little burden and covers the essentials (scope, pagination, native passthrough). What is missing is the sibling disambiguation against snapchat_list_ad_creatives, which is the one thing an agent still has to guess.

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 adds only that pagination flows through next_cursor and that results are scoped to the selected account, which is marginal beyond the schema; 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 creatives") scoped to the selected account, which is enough for an agent to know what it does. However, it never distinguishes itself from the sibling snapchat_list_ad_creatives, which reads as an almost identical capability, so the agent cannot confidently pick between 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?

There is no when-to-use / when-not-to-use guidance and no mention of the obvious alternative, snapchat_list_ad_creatives. The only supplementary sentence ("An ad squad is an ad group/ad set") is terminology trivia that does not influence tool selection at all.

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, so the safety profile is covered by structured data. The description's one added behavioral fact is "verified account ownership," hinting that the call validates the entity belongs to adAccountId and will fail otherwise, but it doesn't say what happens on mismatched ownership or how errors surface.

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

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

A single front-loaded sentence with the verb and resource scope up front; nothing is buried. It loses a point only because the long kind enumeration largely restates the schema enum rather than adding new 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 an output schema, full annotation coverage, and 100% schema description coverage, the description carries little burden. The only meaningful gap is routing guidance versus the per-type list tools, which would be the last piece needed for fully confident selection.

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% — the enum for kind, the UUID-or-numeric entityId rule for audience segments, and the adAccountId/SNAPCHAT_ADS_ACCOUNT_IDS constraint are all documented in the schema itself. The description's kind enumeration merely mirrors the enum and adds no format or constraint detail beyond it, 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 ("Read") and enumerates the exact resource kinds it covers, so an agent knows this is a single-entity fetch keyed by kind + entityId. It does not explicitly distinguish itself from the singular-typed siblings (snapchat_get_campaigns, snapchat_get_ads, snapchat_get_creatives, etc.), so an agent must infer that those are list endpoints and this is the generic by-ID getter.

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: singular "a campaign" plus a required entityId signals "fetch one known entity," which contrasts weakly with the plural list siblings. There is no explicit when-to-use/when-not statement and no alternative tool is named, so the routing decision is left to inference.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and non-destructiveness, so safety is covered; the description goes further by disclosing that monetary values are micro-currency, that 'partial:true' signals a further page of rows, and that empty test-account results should not be read as live performance. These are genuinely useful behavioral facts not present in the annotations, though auth/rate-limit context is absent.

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, front-loaded with the core operation, then the caveats. No filler, no restatement of the tool name, and every sentence carries a distinct fact (semantics, currency, test-account pitfall, pagination).

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 read tool with full schema coverage and an output schema, the definition supplies exactly the missing context: interval boundaries, currency units, pagination signal, and a false-negative warning about test accounts. Return-value structure is delegated to the output schema, so nothing an agent needs to call this correctly 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 the baseline would be 3; the description earns more by surfacing two things the schema does not spell out clearly — that the end of the interval is exclusive and that spend/monetary conversions come back in micro currency. It also flags entity breakdown and granularity up front, tying them to the reporting concept.

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 shape of the operation: an explicit interval with exclusive end, granularity, and optional entity breakdown. Among the siblings (which are entity listers like get_campaigns/get_ads and spec/reference tools), this is the only reporting-stats reader, and the description makes that scope unmistakable.

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 — it is obviously the tool for pulling performance metrics over a time range — but there is no explicit 'use this when… / use X instead' routing, nor any stated prerequisites (e.g. resolving campaign UUIDs via get_campaigns first, or account ID availability). No exclusions or alternatives are 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/non-destructive/openWorld, so the safety profile is covered. The description does add two useful behavioral facts beyond that: results are passed through with full native configuration (raw upstream shape, not normalized) and pagination uses next_cursor. It omits any note on filtering scope, page-size behavior, or rate limits.

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

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

It is short and front-loads the verb+resource, which is good. The second sentence ("An ad squad is an ad group/ad set") does not describe this tool's resource or behavior and reads as a copy-paste artifact, so it 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?

For a three-parameter read-only list tool with 100% schema coverage, full annotations, and an output schema, the description plus structured fields are enough to call it correctly. The remaining gap is conceptual: an agent unfamiliar with Snapchat interaction zones gets no definition or indication of when this data is the right input.

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, including the UUID-not-organization caveat. The description only echoes the cursor/pagination concept via next_cursor and adds no syntax 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?

States a specific verb and resource ("List Snapchat interaction zones") with scope confined to the selected account, which distinguishes it from the campaign/adsquad/ad listers in the sibling set. However, it never explains what an interaction zone actually is, and the trailing sentence defines "ad squad" instead, which is a different entity and leaves the core concept opaque.

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 call this versus snapchat_get_adsquads, snapchat_get_campaigns, or snapchat_get_targeting, nor any prerequisite or exclusion stated. The only implicit signal is that it is a listing call, which an agent could infer 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?

The annotations already declare this as read-only, idempotent, open-world, and non-destructive. The description adds useful behavioral context by noting that results retain full native configuration and that pagination uses next_cursor, which goes beyond what the safety annotations say.

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 listing behavior is front-loaded in the first sentence and is efficient. The second sentence about ad squads is tangential for a lead generation form listing tool and slightly dilutes an otherwise concise definition.

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 described in detail here. The description covers the object being listed, the account scoping, and pagination; combined with the schema and annotations, an agent has enough to invoke it correctly.

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

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

Schema description coverage is 100%, so adAccountId, limit, and cursor are already documented in the schema. The description reinforces the account scope and pagination cursor, but adds little parameter semantics 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?

The description gives a specific verb and resource: "List Snapchat lead generation forms in the selected account." That is clear enough for an agent to identify the operation, though it does not explicitly contrast this tool with nearby read tools such as snapchat_get_creatives or snapchat_get_adsquads.

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 "in the selected account" and the mention of pagination, but the description does not state when this tool should be chosen over alternatives or when it should not be used. The trailing note that "An ad squad is an ad group/ad set" does not help select this tool for lead generation forms.

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 only that pagination is via next_cursor; it says nothing about return volume, ordering, or what 'retaining full native configuration' actually means in output terms.

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 ('An ad squad is an ad group/ad set') is off-topic for a media-listing tool and does not earn its place, dragging an otherwise tight definition down.

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 schema, an output schema, and rich annotations, most structured burden is already carried, so the description only needs to disambiguate. It does not: the boundary between this and the creatives/media-status tools is left entirely implicit, which is the main remaining 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 coverage is 100%, with limit, cursor, and adAccountId each documented in the schema itself. The description's mention of next_cursor simply echoes the cursor parameter, adding no syntax or constraint detail beyond what the schema supplies, 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 gives a specific verb and resource: 'List Snapchat media in the selected account,' and names the pagination affordance (next_cursor). It never distinguishes this from closely-named siblings like snapchat_get_creatives, snapchat_list_ad_creatives, or snapchat_get_media_status, so an agent cannot tell them apart from the text alone.

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

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

There is no when-to-use guidance and no exclusion criteria — nothing says when to prefer this over snapchat_get_creatives or snapchat_get_media_status. The trailing sentence about ad squads being ad groups/ad sets is unrelated to this tool and offers no routing value.

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 needn't restate them. It adds genuinely non-obvious behavior: upload acceptance is not the same as processing readiness, and creative creation is blocked until ready:true, which prevents a costly premature call sequence. It does not discuss polling cadence or auth/account scoping beyond what the schema covers.

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, zero filler, and the core assertion (processing state) leads while the operational consequence follows immediately. 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?

With an output schema present, the description needn't explain return values, and the annotations cover safety. What remains is well covered: what state is read and what the state gates. Only polling guidance and explicit sibling routing are absent, which are minor for a two-param 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%, with both mediaId and adAccountId fully documented in-schema, including the useful 'never an organization ID' constraint. The description adds no further parameter meaning, 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 gives a specific verb and resource — reading an account-owned media object plus its native processing state — which is distinct from the plain listing behavior implied by siblings like snapchat_get_media. It never names that sibling, so the differentiation is implicit rather than explicit, but an agent can still infer this is the status/gate check.

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 clearly states the decision rule for use: only ready:true unlocks creative creation and an accepted upload is insufficient, which tells the agent when this check must be performed. It stops short of naming an alternative tool or listing exclusion cases, so it is strong context rather than a full when/when-not matrix.

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 fully covered by structured data. The description adds the useful prerequisite framing (fetch IDs before campaign/audience creation) but says nothing about result scope, e.g. whether all apps for the account are returned or whether unavailable apps are included.

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

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

A single front-loaded sentence with the resource first and the usage trigger second. Every clause carries information; 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 one-parameter read tool with an output schema and full annotations, the description covers what it does and when to call it. The only residual gap is result scope (ordering/completeness of returned app IDs), which is minor given the output schema likely defines the shape.

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

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

Schema coverage is 100% and the adAccountId parameter is documented with a strong constraint (UUID from SNAPCHAT_ADS_ACCOUNT_IDS, never an organization ID). The description only echoes 'selected ad account', adding no syntax or format 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?

Specific verb (Read) plus specific resource (Snap App IDs) scoped to the selected ad account, which distinguishes it from sibling lookups like snapchat_get_pixels and snapchat_get_segments. No explicit sibling naming, so it stops 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?

Gives clear situational context: call this before creating app promotion campaigns or mobile retargeting audiences. That is a real when-to-use signal, but there are no exclusions or guidance on what to do if the app is absent or how it relates to the other lookup 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, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds useful sequencing context but does not disclose additional traits such as permissions, rate limits, or return behavior; an output schema exists, so return details are less necessary.

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

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

It is a single, front-loaded sentence with no wasted words. The intended use is stated immediately, which is exactly what an agent needs for selection.

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

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

The tool has one fully documented parameter, an output schema, and explicit annotations, so the description need not carry all structural detail. It adequately explains what the tool is for and when to invoke it, though it could mention what kind of pixel data is returned.

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 adAccountId parameter is fully documented in the schema. The description does not add syntax or formatting guidance beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: reading pixels associated with the selected account. It is clear enough to distinguish it from sibling tools that retrieve campaigns, ads, targeting, or segments, though it does not explicitly name those alternatives.

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

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

It gives a concrete usage context: use before configuring conversion optimization or website audiences. However, it does not state when not to use this tool or name an explicit alternative among the many sibling getters.

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 covered. The description adds that results are paginated via next_cursor and that full native configuration is preserved, which is useful behavioral context, but it says nothing about rate limits or what a partial/empty result looks like beyond pagination.

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

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

Two short sentences, front-loaded with the core action, with zero filler. The only structural weakness is that the second sentence is a tangential clarification that adds ambiguity rather than value.

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

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

With an output schema present and 100% schema coverage, the description needn't explain return values or parameters, and annotations cover safety. What is missing is the one thing only the description can supply: a precise definition of 'segments' and how this differs from snapchat_get_adsquads and snapchat_get_targeting.

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

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

Schema description coverage is 100% and all three parameters are documented inline, so the baseline is 3. The description only echoes pagination (next_cursor) and the account scoping; it adds no format, default, or range detail 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 first clause gives a clear verb+resource ('List Snapchat segments in the selected account'), but 'segments' is never defined, and the trailing sentence 'An ad squad is an ad group/ad set' actively muddies the purpose by implying segments are ad squads — which conflicts with the sibling snapchat_get_adsquads. An agent cannot confidently tell whether this lists audience segments or duplicates the adsquad lister.

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

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

No when-to-use guidance and no alternatives named, despite a crowded sibling set (snapchat_get_adsquads, snapchat_get_targeting, snapchat_get_entity). The ad-squad remark reads more like a misplaced glossary note than routing guidance, so the agent gets no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description does add a genuine caveat that the returned material is documentation and 'not proof of account eligibility or live delivery', which usefully warns the agent off treating it as a live capability check. It does not say how current or account-specific the guide is, capping the score.

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 with the content description front-loaded and the caveat after it. No filler, though the final sentence is somewhat cryptic out of context ('all features are available' relative to what?).

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 zero parameters, a full annotation set, and an output schema, the description only needs to explain the content and its limits, which it largely does. The gap is routing: with 20 sibling get_* tools, the agent gets no signal on when this guide is the right source versus health_check or the targeting/spec 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline of 4 applies; no parameter discussion is needed.

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 names a specific verb ('Read') and enumerates the content returned: campaign objectives, audience workflows, creative format prerequisites, and limitations. That is far more informative than the redundant title. It stops short of distinguishing this from siblings like snapchat_get_targeting_specs or snapchat_get_write_schema, which arguably also return reference documentation.

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?

'Use before claiming all features are available' is the only guidance and it frames a narrow precaution rather than a workflow. There is no mention of when to prefer this over snapchat_health_check (live verification) or the other spec tools, and no exclusions are stated.

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

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

Annotations already cover readOnly, idempotent, non-destructive and openWorld, so the safety profile is done. The description adds genuine semantic context beyond that: missing fields mean unknown rather than broad targeting, and performance breakdowns reflect delivery rather than configuration — a real interpretive guardrail an agent would otherwise get wrong.

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, purpose front-loaded, then two tightly scoped caveats. No restatement of the title, no filler, and each sentence carries information the agent cannot get elsewhere.

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 no explanation and the read-only profile is annotation-covered; the interpretive caveats fill the main remaining gap. What's still absent is explicit differentiation from the similarly named targeting_specs and targeting_options siblings, which matters in a 20-tool namespace.

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

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

Both required parameters (adAccountId, adsquadId) are fully described in the schema at 100% coverage, including the UUID format and the 'never an organization ID' disambiguation, so the schema carries the load. The description contributes nothing about parameters, 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?

The first sentence names a specific verb and resource ('Read configured ad squad targeting') and enumerates the sub-domains returned (audiences, exclusions, demographics, geo, placements). It implicitly distinguishes 'configured' targeting from the sibling tools snapchat_get_targeting_specs and snapchat_get_targeting_options, but never names those siblings, so an agent must 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?

Usage is only implied by the word 'configured' versus the specs/options siblings; there is no explicit 'use this when… use get_targeting_specs when…' routing. No prerequisites (e.g., needing a valid ad squad in the account) are stated. The remaining sentences are interpretation caveats, not 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 carry readOnlyHint, idempotentHint, destructiveHint and openWorldHint, so the safety profile is covered. The description adds 'Retains pagination' (partly redundant with the cursor param) and the anti-hallucination warning about inventing category IDs, which is genuinely useful. It says nothing about value volatility or result volume.

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

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

Two tight sentences with the purpose front-loaded and the caution last; nothing is padded. Minor deduction because the partial category enumeration adds bulk without covering the full enum.

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 rich annotations, the description doesn't need to explain returns, and it correctly emphasizes pre-edit discovery. It still leaves gaps: no differentiation from snapchat_get_targeting/_specs and no hint that some categories require countryCode.

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 five parameters are documented in the schema itself; baseline is 3. The description's category list maps loosely to the enum but adds no semantics beyond it, and it never mentions the countryCode dependency for regions/metros/postal_codes, which the schema handles instead.

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') and enumerates example catalogs, so an agent knows what it returns. However, it does not distinguish itself from close siblings like snapchat_get_targeting and snapchat_get_targeting_specs, and it lists only 6 of the 9 enum categories, leaving metros, postal_codes and age_groups unmentioned.

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?

'Discover native targeting values before editing' implies the right moment to call it, and 'do not invent category IDs' is a useful constraint. But there is no explicit when-not guidance and no mention of the sibling tools it overlaps with, so the agent must infer the routing decision.

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, non-destructive and openWorld, so the safety profile is fully covered. The description adds genuine behavioral context that the data is stored separately and may be missing from normal responses, but says nothing about pagination behavior, response size, or rate limits.

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

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

Two short sentences with zero filler, and the key qualifier (specs exceeding 500 criteria) is front-loaded alongside the verb. Nothing repeated 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?

An output schema exists, so return values need not be explained, and annotations plus a fully documented schema cover safety and parameters. The remaining gap is routing: it does not tell the agent how this differs from the sibling snapchat_get_targeting.

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, adsquadId, limit and cursor are all documented in the schema, including UUID formats and cursor semantics. 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: 'Read separately stored targeting specs', plus a distinguishing characteristic (configurations exceeding 500 criteria). It implicitly separates itself from the ordinary ad squad response, but never names the close sibling snapchat_get_targeting, so an agent still has to infer which targeting tool to call.

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 clause 'These can be omitted from the ordinary ad squad response' hints at when this tool is needed — when the main ad squad payload is incomplete. However, there is no explicit when-to-use instruction, no named alternative (snapchat_get_targeting or snapchat_get_adsquads), and no guidance on whether to always call this or only as a follow-up.

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, open-world, non-destructive operation. The description adds valuable behavioral context by warning that the returned fields reflect this server's implementation, not the full Snap API, and that preview rules are included—context not present in 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?

Two dense, front-loaded sentences carry the essential scope and the key caveat without any filler. Every sentence 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?

An output schema exists, so the description need not explain return values. It adequately covers the tool's scope and caveat. Minor room remains to clarify when exactly to choose this tool over other schema/inspection siblings, but the definition is complete enough for correct invocation.

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

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

The sole parameter is fully documented in the schema, including an enumeration of entity types and a clear description. The tool description adds no further param-specific guidance, so baseline 3 applies.

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

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

The description names a specific verb and resource: it discovers implemented creation/edit fields, required fields, and preview rules for a given entity type. It does not explicitly contrast itself with sibling tools like snapchat_get_campaigns or snapchat_get_entity, but its scope as a schema-discovery tool is clear.

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

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

The description implies the tool should be used before creating or editing Snapchat entities, and it clarifies the schema is server-bound rather than exhaustive. However, it never states explicit when-to-use conditions or names alternatives, leaving the agent to infer that this tool precedes write operations.

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 value beyond that by disclosing permission scoping ('permissions-visible metadata') and the operational consequence of the test flag, though it says nothing about what response or error indicates an unhealthy account.

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 padding; the read scope is front-loaded and the test-account caveat follows immediately. Every clause carries information.

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

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

With an output schema, rich annotations, and a single fully documented parameter, the description covers enough to call the tool correctly. The only real gap is the absence of any statement about what the returned result means for health (e.g., whether an invalid account raises an error).

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 property already documents that it is a UUID from SNAPCHAT_ADS_ACCOUNT_IDS and never an organization ID. The description adds nothing further about the parameter, 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?

Specific verb ('Read') plus resource (selected Snapchat ad account) and an enumeration of what is returned (metadata, timezone, currency, test flag). It resolves the vague name 'health_check' into a concrete read operation, though it never names a sibling to distinguish it from the broader snapchat_get_entity.

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

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

Usage is only implied: 'Test accounts cannot serve ads' hints at a pre-flight validation intent, but there is no explicit when-to-use statement and no guidance on when to prefer snapchat_get_entity instead. An agent must infer the appropriate moment to call this.

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, open-world), so the description earns credit for adding real behavior: media URLs are short-lived Snap-hosted links that the server does not download, incomplete formats/media are surfaced rather than hidden, and no performance metrics are derived. These are exactly the surprises an agent needs warned about.

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

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

Four short sentences, purpose front-loaded, each subsequent sentence contributing a distinct operational caveat (incomplete reporting, no performance, URL lifetime). No filler or restatement of the tool name.

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

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

Output schema exists so return shape need not be described, annotations cover safety, and the description still adds the important caveats about short-lived URLs and missing coverage. Only the routing to sibling creative/media tools is left unstated.

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

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

Schema description coverage is 100% and the description adds nothing parameter-specific — the 'omit adIds resolves first ads of the account' behavior is already documented in the schema. 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 ('Resolve') and a specific resource set ('ad-linked Snapchat images/videos, Story children and Collection tiles') and names the payload fields returned. The 'ad-linked' and 'resolve media' framing implicitly separates it from snapchat_get_creatives and snapchat_get_media, but 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 only implied: 'No performance is inferred' scopes it away from insights/reporting tools and 'Incomplete formats/media are reported' hints at its diagnostic role. There is no explicit when-to-use / when-not-to-use, and neither snapchat_get_creatives nor snapchat_get_media is mentioned as an alternative.

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