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

Annotations already establish read-only, idempotent, non-destructive behavior, so the description's value is in what it adds: 'Missing fields are unknown, not unrestricted targeting' prevents a serious misinterpretation of empty results, and the smartPlus note warns there is no fallback to classic settings. Pagination is also disclosed. Only rate-limit/scope behavior 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?

Two sentences, front-loaded with the resource and its field inventory, then the two operational caveats. The field list is dense but each item discriminates the tool's scope; nothing is redundant padding.

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

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

An output schema exists, so return values need not be explained. Combined with 100% parameter coverage and read-only annotations, the description supplies exactly what is missing: pagination, the smartPlus read path, and the semantics of absent targeting fields.

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 advertiserId, campaignId, adgroupIds, page, limit and smartPlus are all documented in the schema. The description's smartPlus sentence largely restates the schema's own explanation, so it adds little beyond the baseline.

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

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

States a specific verb (read) and resource (native ad group configuration) and enumerates the concrete contents: targeting, audience references/exclusions, geo, language, age/gender, placements, budget, schedule. This clearly separates it from tiktok_get_campaigns and tiktok_get_ads by resource level, though it never names a sibling explicitly.

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

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

Usage is implied rather than stated: read ad groups when you need their configuration. The one real routing hint is 'Set smartPlus:true for upgraded Smart+ targeting_spec,' but there is no guidance on when to prefer tiktok_get_targeting or tiktok_get_entities_raw instead, and no 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, openWorldHint, and destructiveHint=false, so the safety profile is fully covered. The description adds useful return-field context (ad ID, name, operation status, creative info) but says nothing about pagination behavior, result caps, or rate limits. It does not contradict 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, zero filler, with the resource and scope front-loaded. Nothing to trim.

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 carry the safety semantics, so the description need not explain return values in depth. What remains missing is how this listing relates to the creatives/videos/spark-ads siblings and any pagination caveat hinted at by the limit parameter.

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

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

Schema description coverage is 100% and all three parameters are documented in the schema, so the baseline of 3 applies. The description adds no meaning beyond the schema — notably it never mentions the adgroupId filter that would let an agent scope the listing.

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

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

Clear verb+resource: 'List ads for a TikTok advertiser', which distinguishes it from get_campaigns and get_adgroups by resource level. It does not, however, contrast itself with the nearby tiktok_get_creatives or tiktok_list_ad_videos siblings, so an agent must infer the boundary.

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

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

The description supplies no when-to-use / when-not-to-use guidance and names no alternatives, despite ~30 sibling tools including creatives, spark ads, and ad videos that could plausibly be confused with this one. Only the phrase 'for a TikTok advertiser' implicitly signals the required advertiserId 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 covered. The description adds which fields come back, but says nothing about batching limits, error behavior for invalid/unauthorized IDs, or rate limits — the remaining gaps an agent would care 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?

One front-loaded sentence with no filler; the resource and payload fields come before any optional detail. Slightly clipped grammar but nothing wasted.

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

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

With rich annotations, an output schema, and a fully documented single parameter, the definition gives enough to call the tool correctly. The only real omission is where advertiser IDs come from, which a sibling tool covers.

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?

Single parameter with 100% schema description coverage ('One or more advertiser IDs'), so the schema carries the burden. The description adds no extra meaning such as how many IDs are practical per call or where to source valid IDs.

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

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

States a specific verb (Get) and resource (advertiser account info) and enumerates the returned fields (currency, timezone, status, balance), which separates it from bulk listing tools. It never names tiktok_list_advertisers 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?

There is no explicit when-to-use guidance and no mention of alternatives such as tiktok_list_advertisers for discovering IDs or tiktok_get_insights for performance data. The only usage signal is the implied 'you need account-level metadata', 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 read-only, idempotent, non-destructive, open-world semantics, so the description's real contribution is the crucial fact that TikTok media URLs are signed and expire — explaining why repeated calls are expected and necessary. It stops short of rate-limit or expiry-window details, but adds meaningful context 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 sentences, front-loaded with the action and followed by the operational trigger. Nothing is padded or 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 present, return values need no explanation, and the description covers why and when to call. Minor gap: it doesn't say whether imageIds/videoIds are required together or how to batch beyond the schema's per-call caps.

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 both the video cap and ID semantics are already documented in the schema, so the description only echoes asset types at a high level. Baseline 3 is appropriate; no additional format or batching guidance is supplied beyond the schema.

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

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

States a specific verb ('Re-resolve') and resource ('fresh, publicly fetchable URLs for specific TikTok library assets'), and names the exact TikTok file paths involved. This clearly separates it from sibling list tools like tiktok_get_video_assets or tiktok_list_ad_videos, which enumerate assets rather than mint URLs.

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?

'Call at display or download time' gives a concrete trigger condition that no other sibling shares. It doesn't explicitly name an alternative or exclusion, but the timing guidance is unambiguous enough that misuse is unlikely.

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 fully covered. The description's 'no report creation or mutation is performed' merely restates those hints and adds nothing about polling cadence, what a pending/failed status looks like, or error behavior for an unknown taskId.

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 resource and key parameter front-loaded and no filler. The 'when async report endpoints are available' clause is slightly vague but occupies little space.

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

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

An output schema exists, so return values need not be explained, and both parameters are schema-documented. However, for a status-polling tool the description omits the practically important context — whether repeated calls are expected, how terminal states are indicated, and what happens for an expired or invalid taskId.

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%: both advertiserId and taskId are documented in the schema, including that taskId originates from task creation outside this MCP. The description only echoes 'by taskId' and adds no format, validity, or cross-parameter meaning, 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 ('Check a TikTok async report task status') keyed to a named parameter ('by taskId'), which no sibling tool in the list covers. The qualifier 'when async report endpoints are available' introduces an odd conditional but does not obscure the core action.

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

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

Implies the usage context (polling a task created elsewhere) and explicitly excludes creation/mutation, but names no alternative tool and gives no when-not guidance or prerequisite ordering. The schema, not the description, is what tells the agent taskId must come from outside this MCP.

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 "Read-only only" adds no information beyond structured fields. The only genuine addition is "where TikTok DMP endpoints are accessible," which hints at an availability gate but never explains what happens for non-DMP advertisers or how access is determined.

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 verb and scope front-loaded; nothing is buried. The second sentence is largely redundant with the readOnlyHint annotation, so it does not fully earn its place.

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

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

Output schema and annotations carry the return-shape and safety burden, and the schema documents all params, so the definition is callable as-is. What is missing is the sibling disambiguation (this vs tiktok_get_audiences) and any explanation of the DMP accessibility condition, both of which materially affect tool 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 description coverage is 100%, so each of the four parameters is already documented in the schema (including the audienceIds/listing tradeoff and the includeSavedAudiences flag). The description adds no parameter-level meaning, which is acceptable given the baseline but leaves no extra value.

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 (Get) and resource (audience details) and enumerates the audience types covered (custom/lookalike/saved), so an agent knows what data comes back. However, it never distinguishes itself from close siblings like tiktok_get_audiences or tiktok_get_audience_overlap, which an agent could easily confuse it with.

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?

"Read-only only" is a safety restatement, not guidance on when to pick this tool. There is no mention of when to use tiktok_get_audiences instead, nor any prerequisite about DMP access other than a vague caveat phrase.

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 'Read-only' in the description is largely redundant. The description does add the useful disclosure that analysis spans multiple entity types including targeting fields, but says nothing about cost, result size, or how overlapThreshold triggers flagging beyond what the schema states.

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

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

A single front-loaded sentence with no filler or repetition. It is perhaps too terse for a seven-parameter diagnostic tool, but there is no wasted language.

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, annotations cover the safety profile, and the schema documents all seven parameters, so the description is not required to explain returns. It is, however, complete enough to identify the tool; the missing piece is comparative guidance against sibling audience 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 baseline is 3. The description hints at the entity scope covered by adgroupIds, campaignId and includeSavedAudiences, but adds no semantics for overlapThreshold or smartPlus beyond what the schema already documents clearly.

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: 'audience overlap diagnostics' scoped to ad groups, custom audiences, saved audiences and targeting fields. An agent can tell it is an overlap analysis read, though it gives no signal to distinguish it from close siblings such as tiktok_get_audience_report or tiktok_get_audiences.

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

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

The description never says when to reach for this tool rather than tiktok_get_audience_report, tiktok_get_audiences, or tiktok_get_targeting, nor does it state preconditions (e.g. needing at least two ad groups to compare). Usage is only implied by the word 'diagnostics'.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the description's job is to add beyond that — and it does: multiple demographics yield separate reports rather than a joint distribution, pagination is explicit, errors are surfaced natively, and it will not infer configured targeting or Custom Audience membership. Those are real behavioral caveats an agent would otherwise get wrong. It stops short of describing result shape or limits, but the output schema covers returns.

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, front-loaded with purpose and scope, with caveats trailing. Slightly dense and clause-heavy, but every clause carries information rather than filler.

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

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

For a 13-parameter reporting tool with annotations and an output schema, the description covers what is queried, at which levels, how demographics are returned, and the error/pagination posture. The remaining gap is routing guidance relative to sibling reporting tools, which is minor given full schema and output coverage.

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

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

Schema coverage is 100%, so the schema already documents all 13 parameters including the dimensions semantics and dataLevel compatibility. The description restates the demographic-separation rule but adds no syntax, default, or format detail beyond the schema — baseline 3 is appropriate.

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

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

States a specific verb and resource ('Read TikTok AUDIENCE performance reports') plus the breakdown axes (age/gender) and aggregation levels (advertiser → ad), which separates it from sibling list/detail tools like tiktok_get_audiences or tiktok_get_audience_details. It does not explicitly name the closest alternative (tiktok_get_insights), so sibling differentiation is implied rather than stated.

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

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

The scope constraints (demographic breakdowns, eligible Smart+ delivery, supported dataLevels) imply when the tool applies, but there is no explicit when-to-use/when-not guidance or named alternative such as tiktok_get_insights for non-demographic reporting. The agent must infer selection from the purpose sentence.

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. The description adds the useful fact that both custom and lookalike audience types are returned, but says nothing about pagination behavior or result size, which the schema partially 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?

A single front-loaded sentence with zero wasted words that immediately identifies the resource and scope.

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 and the input schema is fully documented, so return values and parameters need not be explained. However, with 30+ siblings including three other audience-related read tools, the definition is too thin to reliably route an agent without opening 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% with well-annotated page, limit and advertiserId, so the schema carries the parameter burden. The description adds no parameter-level meaning beyond naming the audience types, so the baseline 3 applies.

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

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

States a specific verb ('List') and resource ('custom and lookalike audiences') scoped to a TikTok advertiser account. It implicitly distinguishes itself from retrieval-style siblings like tiktok_get_audience_details or tiktok_get_audience_report, but never names 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?

Usage is only implied: an agent can infer this tool is for enumerating the audience library. There is no explicit when-to-use guidance and no mention of the several closely-related siblings (audience_details, audience_report, audience_overlap) that a caller must choose between.

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 covered. The description adds a brief return-field summary (ID, name, status, budget, objective), but it does not discuss pagination behavior, rate limits, or authentication needs beyond what annotations already imply. With annotations carrying the main behavioral load, a 3 is appropriate.

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 with zero waste. The core purpose is front-loaded, and the return-field summary follows immediately, making the definition efficient and easy to parse.

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

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

The tool has rich annotations, full schema coverage, and an output schema, so the description need not explain return values in detail. It provides enough context (scope and key return fields) for an agent to call it correctly, though it could mention pagination or filtering to be fully complete.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including the status enum and limit bounds. The description adds no parameter-specific semantics beyond implying the advertiser account scope, so the baseline 3 is correct when the schema does the heavy lifting.

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

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

The description uses a specific verb ('List') and resource ('campaigns') and scopes it to a TikTok advertiser account. It clearly distinguishes campaign-level data from sibling tools like tiktok_get_adgroups or tiktok_get_ads, though it does not explicitly name 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?

Usage is implied by the resource and scope ('List campaigns for a TikTok advertiser account'), but there is no explicit guidance on when to choose this tool over siblings or any exclusions. No prerequisites or filtering recommendations are provided.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds value beyond them: it discloses that each image is validated for carousel usability (a failure mode the agent should anticipate) and that returned music is licensed for TikTok use only. It does not cover error behavior or rate limits, but the added context is substantive.

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

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

Four compact sentences, front-loaded with purpose, then validation behavior, then workflow and licensing caveat. Every sentence carries information; the only mild redundancy is restating the image-matching constraint twice.

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 still covers the pieces an agent needs: input scope, input verification behavior, downstream selection of music_id, and the TikTok-only usage restriction. Complete for a two-parameter read 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 both parameters are fully documented with types, limits (1-35 distinct images), and the advertiser ID format. The description only reinforces the 'use the exact same images' constraint, adding no syntax or format detail beyond the schema — baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get TikTok music recommendations') plus a precise scope qualifier: 'exactly the uploaded images in a standard, non-catalog image ad (one card) or carousel.' That level of scope detail distinguishes it from generic asset/creative siblings, though it never names 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?

Clear context is given (standard non-catalog image ad, one card or carousel) and the downstream workflow is spelled out ('select a returned music_id in the approval preview and use the same images in the ad'). The 'non-catalog' qualifier acts as an implicit exclusion, but no explicit when-not-to-use or alternative-tool guidance is offered.

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 read-only claim largely restates structured data. The description does add real context that the output is derived from ad-level daily reporting and framed as candidate signals rather than verdicts, but says nothing about analysis cost, data freshness, or how sparse data is handled.

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: the core action first, the read-only boundary second. Nothing is padding and nothing 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 values need not be described, and annotations cover the safety profile, so the description is nearly sufficient. It could still hint at the default 14-day window or that results are capped by limit, but those are already in the schema.

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

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

Schema description coverage is 100%, so every parameter including declineThresholdPct and minImpressions is already documented with defaults and bounds. The description adds no parameter-level meaning beyond what the schema provides, which is the expected baseline of 3 when the schema carries the load.

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 analytic resource: find likely creative fatigue patterns from ad-level daily reporting and return refresh recipes. The scope is narrow enough that an agent can distinguish it from generic reporting siblings like tiktok_get_insights or tiktok_get_report_raw, and the closing clause explicitly rules out creative mutation.

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 a useful negative boundary ('does not create, edit, or upload creatives') but never says when to prefer this over tiktok_get_insights or tiktok_get_report_raw for plain performance data, nor any prerequisites beyond the advertiser ID. Usage is implied by the topic rather than routed explicitly.

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 that returned creative details include video, image, and text, but it does not clarify behavior when adIds is omitted or how limit/pagination affects 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?

A single front-loaded sentence with no repetition or filler. Every part of the sentence contributes to identifying the tool's action, resource, and scope.

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

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

The tool is a simple read operation with a full schema, output schema, and annotations that cover safety. However, the description leaves ambiguous how adIds and limit interact with the result set, which matters 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?

Schema description coverage is 100%, so the schema already documents all three parameters. The description mentions creative types but does not add syntax, defaults, or meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Get creative details (video, image, text)' for 'specific ads' in an advertiser account. It is clear what the tool does, but it does not explicitly distinguish itself from siblings such as tiktok_get_video_assets, tiktok_list_ad_videos, tiktok_list_ad_images, or tiktok_get_ads.

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: fetch creative details for specific ads in an advertiser account. It does not say when to use this instead of related sibling tools, nor does it provide exclusions or prerequisite 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, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the operation aggregates across three levels and includes operation_status plus diagnostics, which is useful, but says nothing about pagination behavior, result volume, or latency despite it being an open-world API call.

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity borders on under-specification for a tool spanning three entity levels.

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 parameters are fully documented. However, for a cross-level aggregation tool the description never clarifies what "simple diagnostics" actually surfaces or how includeAds changes granularity, leaving a gap in the agent's ability to predict what it will get back.

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 five parameters are documented in the schema; the baseline of 3 applies. The description loosely maps to campaignId/adgroupId/includeAds by naming campaign, ad group, and ad levels, but adds no meaning beyond the schema (e.g., how filters interact across aggregation levels).

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 concrete verb ("Aggregate") and concrete resources (campaign, ad group, ad delivery status/operation_status), so an agent can tell this is a roll-up status view rather than an entity list. It does not explicitly distinguish itself from siblings like tiktok_get_campaigns or tiktok_get_adgroups, which return entities rather than status, so differentiation is only implied.

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?

"with simple diagnostics" hints at a triage/monitoring use case, but the description never states when to prefer this over tiktok_get_ads, tiktok_get_campaigns, or tiktok_health_check, nor any preconditions. Usage is inferable from the name and context signals rather than 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 readOnlyHint, idempotentHint, openWorldHint, destructiveHint, so the safety profile is fully covered. The description adds the rationale for the tool's existence (uncurated fields, pass-through to the provider) but says nothing extra about rate limits, field-validation failure behavior, or how pageSize interacts with the returned 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 sentences, zero filler. The primary action is front-loaded and the 'escape hatch' qualifier follows immediately as supporting context.

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, annotations cover safety and world-model semantics, and the schema fully documents all eight parameters including the free-form nested filtering object. The description supplies the only thing structured fields can't: why this raw endpoint exists alongside the curated ones.

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 including the nested filtering object and the entityType/orderType enums is already documented in the schema — baseline 3 applies. The description's phrasing ('caller-selected native fields', 'filtering, sorting, pagination') only restates which parameter families exist, adding no format or constraint 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?

States a specific verb and resource ('List TikTok campaigns, ad groups, or ads') plus the distinguishing capability set (native fields, filtering, sorting, pagination). It does not name the overlapping curated siblings (tiktok_get_campaigns, tiktok_get_adgroups, tiktok_get_ads), so the differentiator is only implicit.

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

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

'Escape hatch exposes newly released entity fields without waiting for the MCP's curated schemas' implies the when-to-use case (need fields the curated tools don't yet expose). It never states the inverse — 'use tiktok_get_campaigns instead when a curated schema exists' — nor names which sibling to prefer.

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 a genuinely useful caveat that results are best-effort and may be synthesized from reporting dimensions, but it is phrased in jargon and never says what that means for the caller (e.g. partial or approximate data, empty results when an endpoint is unavailable).

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, no filler, with the dual purpose front-loaded before the implementation caveat. Slightly penalized because the second sentence is compression-heavy jargon that trades clarity for brevity.

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

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

With an output schema present and full parameter documentation, the return shape and inputs are covered elsewhere. What is missing is guidance on the two discovery paths (pixel vs app vs diagnostics), which is the main decision an agent faces with this 7-parameter tool.

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

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

Schema description coverage is 100% across all 7 parameters, including pixelId, appId, bcId, and the date range, so the schema carries the semantic load. The description mentions neither which parameters select which mode nor any interaction between them, so it adds nothing on top of a fully documented schema — baseline 3.

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

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

It names a verb ('Discover') and resources ('pixel/app events', 'tracking diagnostics'), but bundles two loosely related capabilities into one tool without clarifying which mode applies. It also fails to distinguish itself from close siblings like tiktok_get_pixels, so an agent cannot tell from the description alone which to pick.

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 when-to-use guidance, no exclusions, and no named alternative. The clause about 'best-effort endpoint checks plus reporting dimensions as fallback' describes internal behavior rather than telling the agent when this tool is the right choice over tiktok_get_pixels or tiktok_get_audience_report.

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, openWorld), so the description's extra value is the planner-selection behavior and the key constraint that multiple audience breakdowns stay as separate reports and are never joined. That is a non-obvious result-shape trait an agent would otherwise get wrong. Pagination/row-limit behavior is left to the schema.

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

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

Front-loaded with the core action, then the resource pointers, then the routing exception and the no-join constraint. Every sentence carries information, though 'query planning' is filler jargon that could be dropped.

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 15-parameter reporting tool with an output schema and full annotation coverage, the description supplies exactly the missing pieces: which resources resolve metric/dimension keys, how age/gender dimensions are routed, and that audience breakdowns are never merged. Nothing an agent needs to call it correctly is absent.

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 15 parameters including enums and defaults are already documented. The description reinforces reportType auto-defaulting through its routing explanation but adds no syntax or compatibility detail beyond the schema. Baseline 3 applies when the schema carries this much.

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 (query TikTok Ads performance insights) and names the planner/catalog model it runs against. It also names the sibling it delegates to for age/gender breakdowns (tiktok_get_audience_report), so an agent can separate the two without opening schemas. Slightly abstract wording ('query planning') keeps it from a 5.

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

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

Gives concrete routing rules: use tiktok://metrics for metric keys, tiktok://dimensions for dimensions, age/gender dimensions automatically go to the AUDIENCE report, everything else uses the BASIC planner. It stops short of stating when to call tiktok_get_audience_report directly versus letting this tool route.

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 read-only, idempotent, non-destructive, open-world behavior. The description adds useful context about permission-dependent enrichment and explicit fallback warnings when endpoints are unavailable, though it does not cover pagination or warning format.

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

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

Two sentences, front-loaded with the primary purpose and then the permission-dependent caveat. Every clause contributes without repetition or 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?

An output schema exists, so return values need not be explained. The description covers purpose, permission gating, and fallback behavior, but does not mention the discovery order for pixelIds or bcId defaults, though those are handled by schema descriptions.

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

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

Schema description coverage is 100%, so the schema fully documents all five parameters including advertiserId, bcId, limit, pixelIds, and includeEvents. The description adds no additional parameter-level meaning beyond what the schema provides, 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 uses a specific verb ('List') and resource ('TikTok pixels'), and clarifies that pixel event metadata may also be returned. It does not explicitly name a sibling tool, but the scope is clear enough to distinguish this from broader reporting 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?

It mentions permission-gated behavior and fallback warnings, which implies when the tool can be used. However, it does not say when to choose this over alternatives like tiktok_get_events or tiktok_list_advertisers, leaving selection guidance implicit.

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?

Adds substantive behavior beyond the readOnly/idempotent annotations: relative v1.3 path validation, JSON-compatible parameter validation, and explicit blocking of OAuth, mutations, downloads, and lead-record paths. It does not specify what validation errors look like or how authentication is supplied, which keeps it short of a 5 even with an output schema present.

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 sentences with zero filler, front-loading the escape-hatch purpose before the validation and exclusion rules. Every clause 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, rich annotations, and fully described parameters, the description covers what an agent needs to decide to call this and how to shape inputs. It could clarify what 'documented' means and how blocked/validation failures surface, but the essentials are 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 both endpoint and parameters are already documented with examples and the no-credentials constraint. The description only adds the v1.3 relative-path and JSON-compatibility notes, which is marginal value over the schema — baseline 3 is appropriate.

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

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

States a specific verb and resource: a GET-only escape hatch for documented JSON read endpoints not yet modeled by a specialized MCP tool. The phrase 'not yet modeled by a specialized MCP tool' immediately distinguishes it from every specialized sibling like tiktok_get_campaigns or tiktok_get_insights.

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

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

Explicitly scopes when to use it (unmodeled documented JSON read endpoints) and when not to use it (OAuth, mutations, downloads, lead-record paths are blocked). It also implies the alternative class — specialized MCP tools — for endpoints that are already modeled.

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 bar is lower, and the description still adds real behavior: it is synchronous (unlike tiktok_get_async_report_status) and it performs no alias calculation or auto-splitting of incompatible selections, meaning incompatibilities surface to the caller. It does not say how incompatibility manifests (error vs empty result) or how pagination should be followed, which keeps it below a 5.

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 sentences, front-loaded with what the tool does, then the AUDIENCE/demographics note, then the routing rule against two siblings. No filler and no repetition of schema content.

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

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

For a 14-parameter, open-world raw-reporting tool with full schema coverage, rich annotations and an output schema, the description supplies the essentials: scope, when to prefer alternatives, and the no-alias/no-auto-split contract. The remaining gap is that it omits the other reportType values and any note on how incompatible dimension/metric combinations fail, which matters for a raw passthrough 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 dimensions, metrics, dataLevel, filtering and pagination are already documented; the baseline of 3 applies. The description adds one genuinely useful nuance — metric names must be native/documented because no alias resolution happens — but it says nothing about filtering, ordering, date range, or queryLifetime beyond what the schema states, and its BASIC/AUDIENCE framing under-describes the reportType parameter.

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 ('Run a native TikTok ... synchronous report') and specifies that dimensions and metrics are caller-selected, which distinguishes it from the guided/curated siblings. The one weakness is that it names only 'BASIC or AUDIENCE' while the reportType enum also allows PLAYABLE_MATERIAL, CATALOG and BC, so the stated scope is narrower than the tool's actual capability.

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

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

Explicitly gives the selection condition ('Use when a current API field is not yet in tiktok://metrics') and names two alternatives with the reason to prefer them: tiktok_get_audience_report as the guided path for demographics, and tiktok_get_insights as the alias-calculating/auto-splitting option. The agent can route between all three without opening a schema.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so "Read-only diagnostics only" largely restates structured data. The one genuine addition is disclosing which endpoints feed the diagnosis and that the recommendation endpoint is optional, but nothing is said about cost, coverage limits, or what 'maturity' is measured against.

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 purpose, no filler. The second sentence is nearly redundant with the readOnlyHint annotation, which is the only small inefficiency.

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, but the description leaves the core concept opaque: an agent cannot tell what a 'maturity' diagnosis actually yields or how it differs from a plain keyword report. For a six-parameter diagnostic tool this is adequate but thin.

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 and the baseline is 3. The description only implicitly links "optional keyword recommendation endpoints" to seedKeywords and adds no format, default, or interaction details (e.g., how startDate/dataLevel affect the diagnosis) beyond the schema.

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

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

The description pairs a specific verb ("Diagnose") with a specific resource ("TikTok Search Ads maturity") and names the data sources used — keyword/search-term reporting plus optional keyword recommendation endpoints. It is clear what the tool does, though it never contrasts itself with near-neighbours like tiktok_search_keywords or tiktok_get_insights, so an agent must infer the boundary.

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

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

"Read-only diagnostics only" gives a soft usage constraint (diagnostic, not reporting/pulling raw data), but there is no explicit when-to-use / when-not-to-use guidance and no named alternative among the many sibling reporting tools. The context is implied rather than 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered. The description adds real context beyond that: the endpoint-fallback strategy and the fact that missing catalog permissions surface as endpoint warnings rather than an error.

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

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

Two sentences, front-loaded with the read-only diagnostics scope before the fallback detail. Efficient, with no filler, though the fallback clause is dense enough to blur the primary purpose slightly.

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 9-parameter, multi-endpoint hybrid tool, the description leaves unclear what the diagnostics actually measure and when partial results (warnings) versus real data should be expected.

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. The description adds no parameter-level meaning (e.g. how catalogId interacts with the fallback path), 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 and domain — read-only TikTok Shop/catalog/e-commerce diagnostics — and discloses the fallback chain (catalog reporting first, then Shop auction metrics). It stops short of saying what a 'diagnostic' actually reports, which keeps it from a 5.

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

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

It says nothing about when to choose this over siblings such as tiktok_get_insights, tiktok_get_report_raw, or tiktok_get_targeting_catalog, which overlap heavily with catalog/e-commerce reporting. The fallback order is internal behavior, 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 declare readOnly/idempotent/non-destructive, so safety is covered. The description does add genuine behavioral context — that it degrades to a conservative fallback when Spark-specific fields are unsupported — but never says what that fallback yields or how an agent should detect it happened, which is the key operational detail.

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

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

A single sentence with no padding, but the trailing fallback clause is vague relative to its length and the sentence is not front-loaded with what the tool actually returns.

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 shapes need not be restated. Still, for a read tool with four filters and a documented fallback mode, the description leaves the agent without enough information to interpret results or choose the right sibling.

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 every parameter is already documented in the schema, and the description adds no extra meaning about filtering or scoping behavior. 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?

It names a verb ('Return') and a resource ('Spark Ads context from ad fields'), but 'Spark Ads context' is loosely defined — an agent cannot tell what fields come back or how this differs from tiktok_get_ads or tiktok_get_spark_organic_joins. The purpose is recognizable but under-specified.

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

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

There is no statement of when to call this instead of tiktok_get_ads, tiktok_get_spark_organic_joins, or the raw endpoints, and no guidance on how adIds vs adgroupId vs advertiserId-only affect the result. Usage is left entirely 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 readOnly, idempotent, non-destructive and open-world, so 'Read-only only' is largely redundant. The description does add the meaningful caveat that organic identity/post endpoints are permission-gated, which explains partial results — but it says nothing about how failures surface (e.g. warnings) despite the schema flagging 404-prone experimental endpoints.

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

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

Two short sentences with no padding, and the permission qualifier is placed up front. The phrasing is dense and slightly awkward ('Join accessible Spark Ads fields with paid page/post reporting'), but nothing is wasted.

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

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

An output schema exists and all 8 params are documented, so the basics are covered. However, for a tool that merges multiple endpoints with experimental fallbacks, the description should explain the merged shape or degraded-result behavior, which it does not.

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 every parameter including includeOrganicEndpoints and includeExperimentalEndpoints is already documented in the schema. The description adds no parameter-level meaning beyond what is structured, 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 names Spark Ads fields and paid page/post reporting, but 'Join accessible ... fields with ... reporting' is jargon that never says plainly that it returns a merged reporting dataset. It also doesn't distinguish itself from the sibling tiktok_get_spark_ads, which an agent would reasonably consider first.

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?

'when permissions allow' hints at a precondition but there is no statement of when to pick this over tiktok_get_spark_ads or tiktok_get_report_raw, and no mention of what happens when permissions are missing. Usage 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 readOnly/idempotent/non-destructive, so safety is covered; the description adds genuinely value-adding behavior: Smart+ support, preservation of targeting_spec and automatic targeting settings, and the caveat that it will not infer delivered audiences or hidden Smart+ signals. It does not describe output shape or pagination behavior, but the output schema covers the former.

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

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

Front-loaded with purpose, then capability, then exclusion, then alternatives — each sentence carries weight. The mid-sentence enumeration of targeting fields is dense but useful rather than padding.

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

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

With a full input schema, an output schema and read-only annotations, the description supplies what structured fields cannot: the classic vs. Smart+ distinction and the explicit non-coverage of delivered/hidden signals. Remaining gaps are the unmentioned targeting-catalog sibling and no word on pagination expectations for multi-adgroup reads.

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

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

Schema description coverage is 100%, so the baseline is 3. The mention of 'smartPlus:true' and native smart_plus/adgroup/get reads restates what the parameter description already says in detail rather than adding new semantics for the other five parameters.

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

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

Specific verb (read) plus resource (configured ad group targeting), followed by an explicit enumeration of the targeting dimensions covered (custom/lookalike, geo, language, age/gender, placements, interests/behaviors). It also names the two nearest siblings it is not, so an agent can distinguish it without opening a schema.

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

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

'Use tiktok_get_audiences for audience names/types and tiktok_get_audience_report for delivered demographics' gives explicit routing plus the negative boundary ('Does not infer delivered audiences'). The closest confusable sibling, tiktok_get_targeting_catalog, is never mentioned, which keeps this just short of full routing coverage.

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 this is a catalog/reference lookup rather than campaign data, which is useful, but says nothing about pagination, result caps, or advertiser-scoped catalog requirements.

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 first, followed by an enumeration that earns its length by conveying breadth of catalogs. Slightly list-heavy but not 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 an output schema and fully described parameters, the definition is mostly self-sufficient. However, for a tool with 17 catalog options where some (search_keyword_ideas, search_campaign_health) presumably require an advertiserId, the description leaves that conditional context and the query-required cases 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 coverage is 100%, so all four parameters (including the catalog enum and the free-form 'parameters' object) are already documented, establishing a baseline of 3. The description's catalog list largely restates the enum and adds no new meaning about how query text or the pass-through 'parameters' object behave per catalog.

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

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

The description uses a specific verb ('Read') plus a defined resource ('TikTok targeting and planning catalogs') and enumerates the catalog families available, so the scope is concrete. It stops short of distinguishing itself from close siblings such as tiktok_get_targeting or tiktok_search_keywords, so an agent must still infer the boundary.

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

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

Usage is only implied by 'Read ... catalogs' — the description never states when to reach for this tool instead of tiktok_get_targeting (targeting settings) or tiktok_search_keywords (keyword research). No prerequisites (e.g. which catalogs need an advertiserId) 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 behavior, so the bar is lower. The description adds meaningful context beyond annotations: readiness is conditional on positive duration and dimensions, and it clarifies that this call 'Does not upload again.'

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 three short sentences, front-loaded with the core action, then the readiness condition, then the non-upload clarification. There is little wasted text.

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

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

For a simple two-parameter read tool with an output schema and rich annotations, the description is nearly complete. It explains scope and readiness behavior, though it could explicitly route agents away from list/asset siblings.

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 both parameters are already documented as exact TikTok IDs. The description reinforces that the video belongs to 'this advertiser’s media library' but does not add syntax or format details beyond the schema.

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

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

The description gives a specific verb and resource: 'Read one uploaded video from this advertiser’s media library.' The phrase 'one uploaded video' helps distinguish it from list-style siblings such as tiktok_list_ad_videos, but no sibling is explicitly named.

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

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

Usage is implied by the scope ('from this advertiser’s media library') and the required advertiserId/videoId pair, but the description never states when to use this instead of tiktok_get_video_assets or tiktok_list_ad_videos. No exclusions or prerequisites 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 readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds one useful behavioral fact: results are assembled from two endpoint families and only returned 'when available', implying the response may be partial or empty. It does not say what happens when an ad has no video asset or how the two sources are merged.

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

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

A single front-loaded sentence with no padding or redundancy. It is efficient, though the trailing 'when available' is vague enough that it slightly weakens an otherwise tight statement.

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 structure needn't be described, and the annotations carry the safety profile. What remains thin is behavior when no assets are found and how the two sources combine, but for a read-only metadata fetch this is close to 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 each of the five parameters is already documented, which sets the baseline at 3. The description adds marginal meaning by implying two lookup paths (ad-linked via adIds versus direct material lookup via videoIds), but does not explain how adIds and videoIds interact or which wins.

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 ('Return') and resource ('ad-linked TikTok video asset metadata'), so the agent knows what it retrieves. However, it doesn't distinguish this from close siblings such as tiktok_list_ad_videos, tiktok_get_asset_urls, or tiktok_get_uploaded_video, leaving overlap ambiguous. Naming the upstream endpoints ('ad/get and video material endpoints') is implementation detail rather than 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?

There is no guidance on when to use this tool versus the many video/creative siblings, nor any stated prerequisites or exclusions. 'When available' is a hedge about data presence, not a usage condition that helps the agent choose.

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 known. The description's 'Read-only' merely repeats readOnlyHint; what it does add is scope of returned context (parent settings, currency/timezone), but it offers no further behavioral detail such as auth or rate-limit traits.

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

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

Two short sentences with no filler, and the purpose plus timing ('before editing') is front-loaded. Every clause 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 return values need not be explained, and the description covers the pre-write use case well. It could be slightly clearer about what 'parent settings' includes or how smartPlus affects the read, but nothing critical for invocation is missing.

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

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

Schema description coverage is 100% and each parameter already has a description, including the important string-not-number ID constraint and the smartPlus flag. The description adds no parameter-level meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (read) plus the resources it returns: the exact entity, parent settings, and advertiser currency/timezone. This distinguishes it from generic list/get tools like tiktok_get_entities_raw or tiktok_get_campaigns, though 'exact TikTok entity' is slightly abstract without saying which fields are returned.

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

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

Explicitly says when to call it: 'before editing or building a new configuration.' It does not name an alternative to use instead or state when not to use it, but the pre-write workflow context is clear enough for an agent.

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 a genuinely useful guarantee beyond the schema: 'Never returns tokens or secrets', which tells the agent the output is safe to surface. It stops short of saying what happens on auth failure or how the check reports problems.

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 read-only scope and the key security guarantee. No filler or restatement of 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?

With an output schema present and annotations covering the safety profile, the description needs only to frame purpose and constraints, which it does. It could be slightly more complete by noting failure modes (e.g., whether an invalid advertiser ID errors or is reported in the response), 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?

The single optional advertiserId parameter is fully documented in the schema (100% coverage), including its fallback chain to TIKTOK_ADVERTISER_ID and then the first accessible advertiser. The description adds no parameter guidance, so baseline 3 applies since the schema carries the load.

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 diagnostic verb ('health check') plus the exact resources it inspects: credentials, accessible advertisers, and advertiser info. This distinguishes it from siblings like tiktok_get_advertiser_info and tiktok_list_advertisers, which return data rather than validating access.

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 implied use case (verify credentials/advertiser access before running other calls) is clear from 'health check', but the description never states when to prefer this over tiktok_list_advertisers or tiktok_get_advertiser_info, nor any prerequisites. Usage is inferable but not explicit.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior, so the bar is lower — and the description still adds real value by disclosing that image URLs expire in roughly thirty days and that image_url_expires_at carries the exact instant. That is a non-obvious operational trait an agent must know before caching or reusing a URL. It stops short of covering pagination behavior across the whole library.

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 zero filler; the resource and scope come first and the returned-field detail follows. The parenthetical endpoint path and expiry clause are dense but each 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, the description need not enumerate return values, yet it summarizes the key ones and adds the expiry caveat that the output schema would not make obvious on its own. Complete enough for a read-only paginated list tool; only the absence of sibling routing keeps it from a 5.

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

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

Schema coverage is 100%, with all three parameters documented including bounds and TikTok's 100-item page cap, so the baseline of 3 applies. The description adds nothing about advertiserId scope or paging strategy beyond what the schema already states.

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

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

Names a specific verb and resource ("List the advertiser's whole image library") and even cites the backing endpoint (file/image/ad/search), so the agent knows exactly what is returned. Sibling differentiation is implicit rather than explicit — tiktok_list_ad_videos is the obvious contrast, but the description never names it.

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

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

The word "whole" implies an unfiltered full-library enumeration, which is useful context, but there is no statement of when to reach for this versus tiktok_list_ad_videos, tiktok_get_creatives, or tiktok_get_asset_urls. No exclusions or prerequisites are given, so usage must be inferred.

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 the useful disclaimer that results are restricted to the TIKTOK_ADVERTISER_IDS set (i.e., may not be the token's full access), but says nothing about pagination, ordering, or what happens when the allowlist is empty.

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, scope first, return fields second. No filler and nothing 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 no parameters and an output schema present, the description only needs to convey scope and this does so in one clause. The remaining gap is what the TIKTOK_ADVERTISER_IDS restriction actually means operationally.

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 clarify; the baseline for a parameterless tool is 4 and the sentence about token-scoped access is a reasonable substitute for param guidance.

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

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

States a specific verb and resource (list TikTok advertiser accounts) and adds scope ('accessible with the current token'), which separates it from the singular tiktok_get_advertiser_info. The one weakness is the unexplained 'limited to TIKTOK_ADVERTISER_IDS' reference, which is opaque without external knowledge of config.

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 'list ... accessible with the current token', so an agent can infer discovery use, but there is no explicit statement of when to call this versus tiktok_get_advertiser_info or the many other tiktok_get_* retrieval 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/non-destructive, so the safety profile is covered. The description adds real value beyond structured data by disclosing that every TikTok URL is signed and expires after roughly six hours, with a remediation path — a behavioral trait no annotation or schema field 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 sentences, both load-bearing: the first names the resource and output fields, the second carries the expiry warning and remedy. Nothing is repeated and the critical constraint is easy to spot.

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 values, and pagination is covered in the schema. The main remaining gap is that it never positions this tool relative to the other video-retrieval siblings, which an agent would need to choose 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 page, pageSize, and advertiserId are already fully documented in the schema. The description adds no syntax or semantics for the parameters beyond what the schema supplies, so baseline 3 applies.

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

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

States a specific verb and resource ("List the advertiser's whole video library") and enumerates the returned fields, so the agent knows what comes back without opening the output schema. It does not distinguish this listing tool from close siblings like tiktok_get_video_assets or tiktok_get_uploaded_video, which is the main clarity gap.

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 route the agent to tiktok_get_asset_urls for re-resolving expired URLs, which is genuine conditional guidance. However, it gives no when-to-use/when-not guidance against the several sibling tools that also surface videos (tiktok_get_video_assets, tiktok_get_uploaded_video), so the core selection 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=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the useful detail that results are suggestions with search volume estimates, but says nothing about how the seed keywords are expanded or how many suggestions per seed.

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 and return payload front-loaded, zero filler. Nothing to cut.

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, and annotations cover safety. What's missing is how seed keywords drive the results and any usage framing, which matters for an agent deciding when to call this instead of a reporting 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 advertiserId, keywords and limit are already documented in the schema. The description only implies that the keywords parameter acts as seeds; it adds no format, count, or matching guidance beyond 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 ("Get keyword suggestions for TikTok Search Ads") plus the return content ("recommended keywords with search volume estimates"). No sibling tool covers keyword research, so the tool is implicitly distinguishable, though the description never names that 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?

No when-to-use, when-not-to-use, or alternative guidance is given; the Search Ads context is the only usage signal. An agent must infer that this belongs in a keyword-research/planning step rather than reporting, and nothing explains prerequisites like needing a valid advertiserId.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered; the description adds real value by disclosing the three validation rule sets this preflight applies. It stops short of saying whether violations surface as an error or as a warnings payload — though the output schema may cover that.

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 waste, with the preflight timing front-loaded before the list of checks. Nothing repeats the name or 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?

An output schema exists and annotations cover the read-only profile, so the description only needs to explain scope and purpose — which it does. For a 5-param, fully documented validation tool this is sufficient to call it correctly.

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

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

Schema description coverage is 100%, including enum documentation for dataLevel and reportType, so the schema carries the semantics. The description only loosely echoes metrics/dimensions and 'lifetime compatibility' (queryLifetime) without adding format or constraint 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?

States a specific verb (Validate) and a specific resource (TikTok metric/dimension combination), and enumerates the rule classes checked (dimension grouping, lifetime compatibility, metric/dimension compatibility). It clearly is not a data-fetching sibling like tiktok_get_insights, though it never names the execution tool it gates.

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 executing' establishes timing relative to a query run, which is better than pure implication. But it does not name the sibling to run afterward (presumably tiktok_get_insights), nor state what to do when validation fails, so the guidance stays implicit.

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