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

Beyond the annotations, the description adds valuable behavior disclosure: 'Missing fields are unknown, not unrestricted targeting' clarifies the open-world semantics, and 'Paginated' sets pagination expectations. The smartPlus:true note also explains a mode switch that differs from the default classic read, all while remaining consistent with the readOnly/idempotent 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?

Three sentences, each carrying distinct information: what is read, the Smart+ special case, and the missing-fields caveat plus pagination. No filler or repetition of schema details, making it compact and front-loaded.

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

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

Given the rich annotations, a full input schema, and an output schema, the description covers the important behavioral notes that are not in structured data. It could additionally mention when to prefer a sibling tool, but the core information an agent needs to invoke the tool correctly is present.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters, including the smartPlus behavior and defaults. The description mentions smartPlus:true and pagination, but adds little per-parameter meaning beyond what the schema provides, so 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?

The description opens with the specific verb 'Read' and targets a precise resource: 'full native ad group configuration', then enumerating major contents (targeting, audiences, geo, language, age/gender, placements, budget, schedule). This clearly distinguishes the tool from siblings like tiktok_get_ads or tiktok_get_campaigns by identifying exactly which resource is 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?

The use case is clear: call this when you need the full native ad group configuration, including targeting and budget details. It also gives explicit guidance for Smart+ ad groups via 'Set smartPlus:true', though it does not explicitly mention when not to use it or name sibling alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds a list of returned fields but no behavioral context beyond that, such as pagination behavior, rate limits, auth needs, or caveats about operation status or data scope. 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?

The description is a single, front-loaded sentence with no filler. It states the operation and the primary return contents, making it appropriately sized and easy to parse.

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

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

For a simple read-only listing tool with full schema coverage, an output schema, and clear annotation hints, the description plus structured metadata is sufficient for correct invocation. It is slightly incomplete in not mentioning filter behavior or alternative sibling tools, but those gaps are partly covered by the schema and purpose clarity.

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 description adds no additional meaning beyond what the schema already provides for advertiserId, adgroupId, and limit.

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 and resource ('List ads for a TikTok advertiser') and clarifies returned fields (ad ID, name, operation status, creative info). It is clear enough to distinguish ads from campaigns or ad groups, though it does not explicitly contrast with siblings such as tiktok_get_creatives or tiktok_get_adgroups.

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

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

The description gives no guidance on when to prefer this tool over alternatives, no exclusions, and no mention of using adgroupId to narrow results. It only implies usage through the tool name and the phrase 'for a TikTok advertiser,' which is insufficient among many sibling list/get 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 provide readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the fields returned, but this is likely redundant with the output schema. No additional behavioral context (auth, rate limits, pagination) is given, so it adds moderate value beyond annotations.

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

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

The description is a single sentence, front-loaded with the verb and resource, and wastes no words. It efficiently communicates the tool's purpose and key return fields.

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

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

Given the simple one-parameter tool with an output schema and strong annotations, the description is nearly complete. It clearly states the purpose and the parameter's role, though it lacks explicit routing guidance vs. siblings. This is a minor gap for such a focused tool.

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

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

The schema description coverage is 100%, so the sole parameter advertiserIds is fully documented in the schema. The description only hints that the IDs target 'specific' accounts, which is already implied by the schema name. Baseline 3 is appropriate because the schema carries the semantic 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?

The description states a specific verb ('Get') and resource ('TikTok advertiser accounts') and enumerates the return fields (currency, timezone, status, balance). The qualifier 'specific' differentiates it from sibling tiktok_list_advertisers, so an agent can distinguish it without inspecting schemas.

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

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

The description implies usage when you need details for particular advertiser accounts, but it does not explicitly name alternatives or state when not to use it. With siblings like tiktok_list_advertisers, this leaves the agent to infer the selection logic, so it's adequate 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 declare readOnlyHint and idempotentHint. The description adds valuable context about URL expiry and the need to re-resolve, which is not covered by annotations. It doesn't contradict any annotation.

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 no fluff. The key action and rationale are front-loaded, and the structure is clean and efficient.

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

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

With an output schema present and annotations covering safety/idempotency, the description covers the essential purpose and usage timing. The optional nature of imageIds/videoIds is implicit from the schema's required field list, and the video cap is noted in the schema. Nothing critical is missing.

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

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

Schema description coverage is 100%, so all parameters are documented. The description adds minimal parameter info beyond the schema—it mentions the asset types but not specific parameter details. Baseline 3 is appropriate when 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?

The description states a specific action (re-resolve fresh URLs) on a specific resource (TikTok library assets) and lists the asset types (file/video/ad/info and file/image/ad/info). It is clear and not a tautology. It doesn't explicitly name an alternative sibling, but the purpose is distinct from listing or retrieving assets.

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 explicitly says to call at display or download time and explains why (URLs are signed and expire). This gives clear contextual guidance. It doesn't state when not to use or name alternatives, but the when-to-use is well-defined.

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?

Given the rich readOnly/idempotent/destructive annotations, the bar is lower; the description adds a useful caveat that no report creation or mutation is performed, which is slightly beyond the annotation. However, it doesn't disclose polling behavior, error semantics, or availability details, so it adds only modest behavioral context.

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

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

Two succinct sentences with no filler. The main lookup action and the read-only caveat are front-loaded, making the description easy to scan.

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

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

With complete parameter descriptions, an output schema, and strong annotations, the description covers most of what the agent needs. The only notable gap is the vague 'when async report endpoints are available' condition, which is not elaborated.

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

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

Schema description coverage is 100%, with both taskId and advertiserId documented in the input schema. The description only repeats 'by taskId' and adds no semantic value beyond the schema, so it earns the baseline 3.

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

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

The description uses a specific verb ('Check') and resource ('TikTok async report task status') and identifies the lookup key (taskId). It is clear about what it does, but it doesn't explicitly differentiate from sibling tools or name an alternative, so it stops short of the highest rating.

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 provides a rough condition ('when async report endpoints are available') and disclaims mutation, but the condition is undefined and no alternative tool is named for creating or mutating reports. The use case is implied rather than explicitly contrasted with alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description reinforces read-only status and adds a mild availability qualifier about DMP endpoints, but does not disclose deeper behaviors like pagination, result shape, or endpoint-specific limitations. No contradiction exists.

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

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

The description is short and front-loaded with the core action and resource. The phrase 'Read-only only' is somewhat redundant given the annotations, but it does not bloat the description materially.

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 read-only tool with a complete input schema and an output schema, the core information is present. However, the description lacks guidance on how this tool relates to tiktok_get_audiences and leaves the 'DMP endpoints accessible' condition ambiguous, so completeness is adequate but not strong.

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 parameters are already documented in the schema. The description itself adds little about how limit, audienceIds, advertiserId, or includeSavedAudiences behave beyond what the schema provides, earning the baseline.

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

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

The description clearly states a read-only GET operation on audience details and specifies the audience types: custom/lookalike/saved. This helps distinguish it from report-oriented tools, though it does not explicitly name sibling tools like 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 only usage hint is 'where TikTok DMP endpoints are accessible,' which is vague and does not explain when to choose this tool over tiktok_get_audiences or tiktok_get_audience_report. No explicit when-to-use or when-not-to-use guidance is 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 readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Read-only' agrees with that. The description adds modest context about the diagnostic scope, but no additional behavioral traits such as rate limits, auth requirements, or how the overlap is computed. With annotations covering the safety profile, 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?

The description is one focused sentence that front-loads the core purpose and scope. There is no filler, no redundant restatement of the schema, and no wasted words.

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

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

For a read-only diagnostic tool, the one-line description plus rich annotations, a detailed schema, and an output schema is almost complete. It loses one point because it doesn't clarify the relationship between the compared entities or suggest the intended use case, leaving some agent reasoning to inference.

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 even without parameter details in the description. The entity list loosely maps to parameters like adgroupIds, includeSavedAudiences, and smartPlus, but it does not add meaning beyond the schema. The schema itself documents defaults, bounds, and smart_plus behavior.

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 diagnostic resource — audience overlap — and names the entity types it spans: ad groups, custom audiences, saved audiences, and targeting fields. It clearly differentiates from sibling tools like tiktok_get_audience_details and tiktok_get_audience_report by focusing on overlap rather than details or reports.

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

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

The description gives no guidance about when to choose this tool over sibling audience tools or how it relates to tiktok_get_audiences, tiktok_get_audience_details, tiktok_get_audience_report, or tiktok_get_targeting. There is no when-to-use or when-not-to-use signal; the agent must infer suitability from the name and scope alone.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, covering the safety profile. The description goes beyond this by disclosing that multiple demographics return separate reports (not a joint distribution), that pagination and native provider errors are explicit, and that the tool does not infer configured targeting or Custom Audience membership. This is meaningful behavioral context, though it doesn't cover rate limits or response-size nuances, which the output schema may partially address.

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 sentences with no fluff. The first sentence front-loads the core action, resource, and scope; the second clarifies an important behavioral nuance; the third covers error/pagination behavior and a key limitation. Every sentence earns its place and the structure supports quick scanning.

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

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

Given the tool's complexity (13 parameters, 5 required, output schema present, annotations provided), the description is largely complete. It covers the operation, scope, demographic behavior, pagination/errors, and non-inference caveats. The only minor gap is that it does not explicitly mention metric/dimension compatibility with data levels, but the schema descriptions already address that, so the description does not need to duplicate it.

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

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

Schema description coverage is 100%, so every parameter already has a description in the input schema. The description restates the key semantic point about separate reports for multiple demographics, which is already present in the dimensions parameter description. It does not add new parameter-level meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('Read'), a precise resource ('TikTok AUDIENCE performance reports'), and the key dimensions (age/gender) and levels (advertiser, campaign, ad group, ad). It distinguishes itself from siblings like tiktok_get_audience_details and tiktok_get_audience_overlap by focusing on performance reports by demographics, and the Smart+ eligibility note adds valuable scope.

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

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

The usage context is clear: an agent would call this when needing age/gender audience performance reports. It also states limitations (separate reports, no inference of targeting or Custom Audience membership), which guides expectations. However, it never explicitly names alternatives or gives 'when not to use' guidance relative to sibling tools like tiktok_get_audience_details, so the routing is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety and side-effect profile. The description adds no further behavioral context (e.g., pagination behavior, rate limits, or response format). Given the annotations, this is adequate but not enriched beyond the structured data.

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

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

A single, front-loaded sentence that directly states the function and scope. No wasted words, and the essential information is presented immediately.

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

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

The tool is simple with only three parameters and no nested objects. An output schema exists, so return structure is covered. The description, combined with the schema and annotations, provides sufficient context for an agent to invoke the tool correctly. Minor gaps like pagination usage 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 all three parameters (advertiserId, page, limit) are fully documented in the schema. The description does not add any parameter-specific nuance beyond what the schema already provides. With high schema coverage, the baseline of 3 is appropriate.

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

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

The description clearly states the action (list) and the resource (custom and lookalike audiences) for a specific account. It distinguishes from siblings like tiktok_get_audience_details (which implies details for a single audience) and tiktok_get_audience_report (which implies reporting). The scope is unambiguous and the tool's function is immediately evident.

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 conveys what the tool does but does not explicitly state when to use it versus alternatives such as tiktok_get_audience_details or tiktok_get_audience_overlap. No explicit exclusions or alternative routing is provided; the usage context is implied by the sibling names 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, openWorldHint=true, and destructiveHint=false, and the description is consistent with them. The description adds the concrete returned field list, but since an output schema exists, this is modest extra behavioral context; pagination and status filtering behavior are 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?

The description is a single front-loaded sentence with no wasted words or redundant restatement of the tool name. It communicates action, scope, and return contents efficiently.

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

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

This is a low-complexity read-only list operation with rich parameter descriptions, strong annotations, and an output schema. Nothing critical is missing for an agent to select and invoke it correctly, and the resource name 'campaigns' makes the intended target unambiguous.

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

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

The input schema has 100% description coverage for all three parameters, including limit bounds and statusFilter enum semantics, so the schema carries the parameter-level explanation. The description only echoes the advertiser account scope without adding further parameter detail, so a baseline of 3 is appropriate.

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

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

The description states a specific verb ('List'), a resource ('campaigns'), a scope ('for a TikTok advertiser account'), and the main returned fields (ID, name, status, budget, objective). This makes it immediately distinguishable from sibling tools like tiktok_get_ads and tiktok_get_adgroups.

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 intended use case is inferable from the description and the required advertiserId, but there is no explicit statement of when to choose this tool over alternatives. It does not mention exclusions or sibling tools, so usage guidance 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 flag read-only/idempotent/non-destructive, and the description reinforces safety while adding the non-obvious behavior that it 'verifies each image is carousel-usable.' It also explains the downstream workflow—select a returned music_id in the approval preview and reuse the same images—and the TikTok-only restriction, which are useful context beyond 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?

Three sentences, each earning its place: the first states the core action and scope, the second reveals verification and read-only behavior plus the follow-up workflow, and the third restricts usage. Information is front-loaded and no filler is present.

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

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

Given only two schema-covered parameters, an output schema, and annotations that establish safety, the description covers the operational context an agent needs: when the call applies, what it validates, and what to do with the result. The main workflow note about approval preview and matching image IDs makes the tool self-sufficient 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?

Both parameters are already fully described in the schema (100% coverage), including 'ordered list of 1-35 distinct uploaded image IDs' and the exact numeric ID requirement, so the description carries no additional load. The description only restates the same-images requirement rather than adding new parameter detail, matching the baseline-3 standard for full schema coverage.

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

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

Opens with 'Get TikTok music recommendations', naming a specific verb and resource. Scope is sharpened by 'for exactly the uploaded images in a standard, non-catalog image ad (one card) or carousel', which distinguishes it from the sibling read tools. No ambiguity about what it returns.

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

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

The description clearly states the intended use case: music recommendations for a standard non-catalog image ad or carousel built from the exact uploaded images. It implicitly excludes catalog ads but does not name a fallback or explicitly say when not to use it, so it falls one step short of full exclusionary 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, and destructiveHint=false. The description adds value beyond annotations by stating the tool 'Does not create, edit, or upload creatives' and by framing the output as 'read-only refresh recipes' – this clarifies the operational contract. It does not disclose details like rate limits or whether the analysis is deterministic, but the annotations cover the safety profile well.

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 read-only clarification is placed immediately after. Every sentence earns its place.

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

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

The tool has a rich input schema (100% coverage), a true output schema, and annotations covering read-only/idempotent behavior. The description is complete enough for an agent to select and invoke the tool correctly. A minor gap: it does not explain what a 'refresh recipe' contains or how the fatigue patterns are computed, but the output schema likely covers return values.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters. The description adds the conceptual context that minImpressions and declineThresholdPct are 'candidate signal' thresholds, but it does not add syntax or format details beyond the schema. Baseline 3 is appropriate because the schema carries 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 states a specific verb ('Find'), a specific resource ('creative fatigue patterns from ad-level daily reporting'), and explicitly distinguishes itself from write operations ('Does not create, edit, or upload creatives'). It clearly differentiates from sibling read tools by naming the fatigue-analysis purpose.

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

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

The description implies when to use it: when the agent needs to identify likely creative fatigue patterns from ad-level daily reporting. It does not explicitly name alternative sibling tools or state when not to use it, but the read-only framing and the 'read-only refresh recipes' phrasing provide clear context. A small gap: no explicit exclusion such as 'use tiktok_get_creatives for raw creative metadata'.

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 read-only behavior is covered. The description adds minimal context about the content types returned but does not disclose pagination behavior, authentication needs, or how the optional adIds affect the result scope.

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

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

The description is a single, front-loaded sentence with no filler. The parenthetical '(video, image, text)' efficiently conveys the returned content types without extra prose.

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

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

With a rich output schema, complete parameter descriptions, and safety annotations, the description is largely adequate for a read-only retrieval tool. The only gap is that it doesn't specify whether omitting adIds returns all creatives for the advertiser, which could affect how an agent invokes it.

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

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

Schema description coverage is 100%, so the schema already documents advertiserId, adIds, and limit with defaults and bounds. The description adds no new parameter semantics beyond the general phrase 'for specific ads,' so the baseline 3 is appropriate.

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

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

The description gives a specific verb and resource—'Get creative details (video, image, text) for specific ads'—so an agent can understand what the tool returns. It doesn't explicitly differentiate from sibling tools like tiktok_get_ads or tiktok_list_ad_videos, but the resource and content types are clear.

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

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

The description implies the tool is for retrieving creative details, but it gives no guidance on when to use this tool versus siblings such as tiktok_get_ads, tiktok_get_video_assets, tiktok_list_ad_videos, or tiktok_list_ad_images. There is no mention of exclusions or alternatives.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so this is clearly a safe read operation. The description adds little beyond 'simple diagnostics,' which is vague and doesn't disclose pagination behavior or response structure (though the output schema covers that). No contradiction with annotations.

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

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

The description is a single sentence of 11 words, with no filler or redundancy. It is front-loaded with the key action and scope, though the phrase 'simple diagnostics' is somewhat under-specified.

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

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

Given the existence of an output schema and comprehensive parameter descriptions, the description is adequate but not rich. It lacks guidance on when to use the tool versus siblings and what 'simple diagnostics' entails, which an agent might need for correct 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?

The input schema has 100% description coverage for all five parameters, so the schema already explains limit, adgroupId, campaignId, includeAds, and advertiserId. The tool description provides no additional parameter meaning beyond what the schema offers.

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

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

The description uses the specific verb 'Aggregate' and names the resources (campaign, ad group, ad delivery status/operation_status). It clearly distinguishes from sibling tools like tiktok_get_campaigns or tiktok_get_adgroups by focusing on aggregate status and diagnostics.

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 alternatives such as tiktok_get_campaigns or tiktok_get_ads. No exclusions or conditions are provided; the agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds context about exposing newly released fields and caller-selected native fields, but does not go beyond that into caveats like invalid field errors or pagination continuation behavior; this is acceptable given annotation coverage but not exceptional.

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 resource, and every clause earns its place. The second sentence justifies the tool's existence as an escape hatch rather than repeating schema information.

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

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

For a raw/open-world tool with a full input schema and output schema, the description is sufficiently complete: it states what is listed, the flexible field selection model, and the reason to prefer it over curated endpoints. It could name the curated siblings or caution about field validation, but the schema already carries most of that burden.

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

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

Schema description coverage is 100% and every parameter already has a meaningful description (e.g. native provider fields, filtering object example, pagination). The description's mention of caller-selected fields, filtering, sorting, and pagination is an accurate summary but adds little per-parameter meaning above 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 opens with a specific action and resource—listing TikTok campaigns, ad groups, or ads—and immediately distinguishes the tool as a raw GET escape hatch from the MCP's curated schemas. An agent can tell it apart from curated siblings like tiktok_get_campaigns or tiktok_get_ads and understand its broader scope.

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 clear context for when the raw tool is appropriate: when newly released native fields are needed before curated schemas catch up. It does not explicitly name the curated alternatives or state when not to use it, so it stops short of a full when/when-not guide.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context with 'best-effort endpoint checks plus reporting dimensions as fallback', but it does not disclose rate limits, error conditions, or what happens when endpoints are 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 with no filler: the core purpose is front-loaded, and the fallback mechanism is stated compactly. Every phrase 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, full parameter descriptions, and annotations covering read-only/idempotent behavior, the description is largely complete. The only noticeable gap is that 'best-effort endpoint checks plus reporting dimensions as fallback' is not expanded, but structured data makes up for most of that ambiguity.

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 (advertiserId, bcId, appId, pixelId, date range, limit) is already fully documented. The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description names a specific resource ('pixel/app events or accessible tracking diagnostics') and scopes it to an advertiser, which distinguishes it from list-style siblings like tiktok_get_pixels. The verb 'Discover' is slightly vague, but the object is concrete enough for an agent to identify the tool's job.

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

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

The description implies the use case: finding pixel/app events and tracking diagnostics for an advertiser. It does not explicitly state when to prefer this over alternatives or name any sibling alternative, so selection guidance relies mainly on inference from the purpose.

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

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

Annotations already cover the safety profile (readOnlyHint=true, idempotentHint=true, destructiveHint=false), so the description's burden is lower. It adds genuinely valuable behavioral context beyond the schema: automatic routing of age/gender to AUDIENCE reports, the 'never joined' guarantee for multiple audience breakdowns, and the existence of query planning. No contradictions with annotations. A 4 rather than 5 because it doesn't disclose error behavior, rate limits, or when queries become async (a sibling async-status tool exists).

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

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

Four sentences, each earning its place: purpose in the first sentence, resource lookup in the second, routing in the third, and the no-join caveat in the fourth. The structure is front-loaded and logical. A 4 rather than 5 because the opening mention of 'query planning' is never elaborated, leaving a slightly vague concept in the most important sentence.

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

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

For a 15-parameter tool with an output schema and safety annotations, the description covers the critical judgment points: where to source valid metric/dimension keys, how report types are chosen, and how the tool relates to the audience-report sibling. What's missing is modest — no mention of pagination beyond what the schema's 'follow nextPage' already says, no async/rate-limit behavior. Given the output schema and annotations pick up the rest, this is reasonably 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 baseline is 3. The description does add some semantic value by instructing the agent to consult tiktok://metrics and tiktok://dimensions for valid keys (which enriches the metrics and dimensions parameters) and by encoding the reportType routing rule (explicit BASIC with demographics is rejected). However, the schema already documents date formats, limits, enums, and defaults, so the description isn't carrying a heavy parameter load. A 3 is correct.

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

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

The description opens with a specific verb+resource pair ('Query TikTok Ads performance insights') and immediately frames the tool as a catalog-driven query planner. It differentiates itself from the tiktok_get_audience_report sibling by explicitly stating that age/gender dimensions route to that tool, and it also distinguishes itself from the raw report tools in the sibling list. The purpose is unambiguous and well-scoped.

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 explicit when-to-use routing rules: age/gender dimensions go through tiktok_get_audience_report, other dimensions use the BASIC planner, and audience breakdowns are never joined. It also tells the agent where to look up valid metrics and dimensions (tiktok://metrics and tiktok://dimensions), which is practical selection guidance rather than leaving it to inference. This is strong alternative-routing information.

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, and non-destructive behavior. The description adds valuable context beyond those: pixel event metadata is only fetched 'when permissions allow it,' and the tool 'falls back with explicit warnings when endpoints are unavailable.' This discloses real-world failure modes.

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

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

Two compact sentences with no filler. The core action is front-loaded, and the fallback/warning behavior is stated in one short second sentence.

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

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

For a read-only listing tool with full schema coverage, annotations indicating safety, and an output schema, the description provides everything an agent needs to select and invoke the tool correctly. It also covers permissions and fallback behavior, which are the main practical uncertainties.

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

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

Schema coverage is 100%, so all five parameters are already documented in the schema. The description adds only a high-level reference to pixels, event metadata, and advertiser scope, but no meaningful parameter-level meaning beyond what the schema provides. 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?

The description uses a specific verb and resource: 'List TikTok pixels and, when permissions allow it, pixel event metadata for an advertiser.' It clearly states the operation's scope and differentiates the tool from siblings by focusing on the pixel resource rather than campaigns, ads, or 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?

No explicit guidance is given for when to use this tool versus alternatives like tiktok_get_events or other listing tools. The description mentions permission limits and fallback behavior, but it does not state when this tool should be preferred or when another sibling would be more appropriate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond that: relative v1.3 path validation, JSON-compatible query parameter validation, and the specific blocked path categories. GET-only fully aligns with the readOnly annotation; no contradiction.

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. The purpose is front-loaded ('Advanced GET-only... escape hatch') before constraints, and each clause earns its place — path validation, block categories, and scope are all packed in efficiently.

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

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

For a generic escape hatch with an output schema and rich annotations, the description is nearly complete: it covers purpose, scope, validation behavior, and exclusions. The only minor gap is not spelling out what happens on an invalid or non-allowlisted path, which would further guide error handling.

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

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

Schema coverage is 100% and the endpoint parameter carries concrete examples (split_test/result/get, file/video/ad/info, store/list), so the schema does the heavy lifting. The description adds one meaningful constraint beyond the schema — 'JSON-compatible query parameters' — which specifies the accepted format for the parameters object.

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 the TikTok Business API's documented JSON read endpoints. It explicitly carves out its niche ('not yet modeled by a specialized MCP tool'), which distinguishes it from the 34 specialized siblings like tiktok_get_ads and tiktok_get_campaigns. No ambiguity about what it is or when it applies.

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 condition 'not yet modeled by a specialized MCP tool' is an explicit when-to-use signal that routes the agent away from siblings, and the blocked categories (OAuth, mutations, downloads, lead-record) define exclusions. However, it stops short of naming concrete alternative tools for those excluded cases, leaving some routing 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 carry readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false. The description adds real behavioral limits beyond those: the report is synchronous, it does not calculate aliases, and it does not auto-split incompatible selections. No contradiction with 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?

Three sentences, front-loaded with the core purpose, then audience scope, then routing guidance. No filler, though the second sentence packs two ideas (demographic support plus the guided alternative) into one sentence, making it slightly denser than ideal.

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 raw report tool, the description covers purpose, when-to-use, alternatives, and behavioral limits. Schema at 100% coverage, annotations, and an output schema carry the remaining load (pagination is already explained in the pageSize description). Nothing needed for correct 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%, so baseline 3 applies. The description adds modest parameter meaning ('AUDIENCE supports demographics such as age/gender at campaign/adgroup levels'), but compatibility constraints are already documented in the schema property descriptions, so added value is marginal.

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

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

States a specific verb+resource ('Run a native TikTok BASIC or AUDIENCE synchronous report') with caller-selected dimensions/metrics. Explicitly distinguishes from siblings: 'unlike tiktok_get_insights, this tool does not calculate aliases or auto-split incompatible selections' and points to tiktok_get_audience_report as the guided path.

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 when a current API field is not yet in tiktok://metrics' gives an explicit trigger condition. It also states when not to use: tiktok_get_insights handles aliases/auto-splitting, and tiktok_get_audience_report is the guided audience path — clear alternatives with selection criteria.

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 supply readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description reinforces read-only behavior and adds that it works from keyword/search-term reporting and optional keyword recommendation endpoints, but it does not add significant behavioral detail beyond the annotations.

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

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

Two short sentences, front-loaded with purpose. The second sentence restates read-only behavior already present in annotations, which is slightly redundant, so not a perfect 5.

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 an output schema, full schema parameter descriptions, and strong annotations. The description adequately states the tool's purpose and data sources; combined with structured fields, an agent has enough to invoke it. It lacks explicit usage guidance, which is already scored separately.

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

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

Schema coverage is 100%, so the baseline applies. The description does not explain parameter syntax or defaults, though 'optional keyword recommendation endpoints' loosely maps to seedKeywords. The schema carries parameter meaning.

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

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

The description uses a specific verb ('Diagnose') and a specific resource ('TikTok Search Ads maturity') and names the data sources. It is clear, but it does not explicitly differentiate from sibling diagnostic tools such as tiktok_shop_catalog_diagnostics or tiktok_creative_fatigue_recipes.

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 intended use is implied by 'Diagnose TikTok Search Ads maturity' and 'Read-only diagnostics only,' but there is no explicit guidance on when to choose this tool over sibling tools or when not to use it. No alternative tools are named.

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

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

The description adds valuable behavior beyond the annotations: it discloses a fallback chain (catalog reporting → Shop auction metrics) and notes that endpoint warnings are returned when catalog permissions are unavailable. This supplements the readOnlyHint, openWorldHint, and idempotentHint without contradicting them.

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 compact sentence that front-loads the read-only domain and packs in the fallback behavior and warning behavior. Every part earns its place; there is no filler or repetition of annotation data.

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

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

Given a fully described schema, an output schema, and annotations covering the safety profile, the description covers the essential behavioral complexity—fallback logic and permission warnings. The only notable gap is the lack of guidance for choosing this tool over the many reporting siblings, but that is a usage-guideline concern rather than a completeness gap for invoking it correctly.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the input schema. The description itself contributes no additional parameter-level semantics beyond what the schema already provides, which is acceptable at the baseline for high coverage.

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

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

The description identifies a specific domain—TikTok Shop/catalog/e-commerce diagnostics—and explains the core behavior of trying catalog reporting first, then Shop auction metrics. It is clear about the read-only nature, though 'diagnostics' is a noun rather than an explicit verb like 'retrieve' or 'get'. It does not explicitly contrast with sibling tools, but the scope is distinctive enough.

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 or when-not-to-use guidance is provided, and no alternatives are named relative to siblings like tiktok_get_insights or tiktok_get_report_raw. The phrase 'TikTok Shop/catalog/e-commerce diagnostics' implies a niche use case, but the description leaves the choice 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the 'conservative fallback if Spark-specific fields are not supported' behavior, which is a useful behavioral trait beyond annotations. However, it doesn't disclose error handling, rate limits, or what 'conservative' means in practice.

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

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

The description is a single, compact sentence with no filler. It front-loads the primary action (return Spark Ads context) and mentions the fallback. It is concise but not overly terse, earning a strong score.

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

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

Given the tool's low complexity (4 parameters, no nested objects), the presence of an output schema, and the annotations covering safety, the description adequately covers what an agent needs. The fallback behavior is mentioned, and the return format is handled by the output schema. Nothing critical is missing, though the meaning of 'Spark Ads context' could be elaborated.

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

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

Schema description coverage is 100%, so all four parameters (adIds, limit, adgroupId, advertiserId) are already documented. The description adds no parameter-specific meaning beyond what the schema provides. The baseline of 3 applies since the schema carries the full burden.

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

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

The description clearly states the tool returns Spark Ads context from ad fields, with a specific fallback behavior. It distinguishes itself from siblings like tiktok_get_spark_organic_joins by naming the resource (Spark Ads) and the conservative fallback. However, it doesn't explicitly state what 'Spark Ads context' includes, relying on the output schema for detail.

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

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

The description implies usage for retrieving Spark Ads context when available, but provides no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives among the sibling tools. The fallback behavior hints at graceful handling, but the agent is left to infer the appropriate context for invocation.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Read-only only' merely repeats that. It does add useful context by mentioning permissions and optional organic endpoints, which implies some requests may fail or be skipped. However, it does not disclose failure behavior, pagination, or rate-limit concerns beyond what the schema already 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?

The description is short and front-loaded with the core join concept, but the phrase 'Read-only only' is redundant and slightly awkward. The first sentence is dense and could be more legible, yet there is no substantial waste.

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

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

With an output schema, full parameter schema coverage, and rich annotations, the description provides a serviceable high-level orientation. However, for a tool with 8 parameters and sibling tools like tiktok_get_spark_ads, it lacks enough context about what the joined output contains, when to select it over alternatives, and how the optional endpoints behave when permissions are insufficient.

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 eight parameters with defaults, bounds, and filters. The description adds no parameter-level detail, so it does not exceed the baseline expected when the schema carries the semantic weight.

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 ('Join') and names the resource ('Spark Ads fields', 'paid page/post reporting', 'organic identity/post endpoints'). It conveys that this tool merges multiple data sources, which is reasonably distinct from a plain get_tool. It could be clearer about what the returned joined record looks like, but it is not tautological or vague.

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

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

The description gives no explicit guidance about when to use this tool versus alternatives. It does not mention tiktok_get_spark_ads, tiktok_get_ads, or tiktok_get_insights, nor does it state exclusion criteria. The only conditional context is 'when permissions allow,' which is about endpoint availability rather than tool selection.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description need not repeat safety. It adds important behavioral context: it preserves targeting_spec and automatic targeting settings, does not fall back to classic settings when smartPlus is true, and does not infer delivered audiences or hidden Smart+ signals. This goes beyond annotations and clarifies scope and limitations.

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 concise and front-loaded with the tool's primary purpose, followed by scope limitations and sibling references. It avoids redundancy with the schema and annotations. It is slightly dense but every sentence adds information, earning a 4 rather than a 5 due to the density of technical terms (e.g., Smart+) that might require quick parsing.

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

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

Given the tool's moderate complexity and the presence of a rich schema and annotations, the description is complete enough for an agent to invoke it correctly. It covers the key behavioral nuances (Smart+ handling, no inference of delivered audiences) and routes to appropriate siblings. The output schema exists, so return format details are not needed. Nothing essential is missing.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema itself. The description adds value by explaining the smartPlus parameter's role and behavior (reads native targeting_spec, no fallback), which is not fully captured in the schema. It also clarifies that adgroupIds restricts results, adding semantic context beyond the schema's terse descriptions.

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

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

The description clearly states the tool reads configured ad group targeting and audience references, enumerating specific targeting dimensions (e.g., geo, language, age/gender, placements). It distinguishes itself from sibling tools like tiktok_get_audiences and tiktok_get_audience_report by explaining what it does not do (inferring delivered audiences or hidden Smart+ signals).

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 explicitly provides usage context: it supports both classic and upgraded Smart+ ad groups, and instructs to use 'smartPlus:true' for upgraded Smart+ ad groups. It also explicitly names alternatives (tiktok_get_audiences, tiktok_get_audience_report) and what they are for, giving clear when-to-use vs. when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful functional scope by listing the catalog categories, but it does not describe return format, pagination, rate limits, or whether certain catalogs may be unavailable for some advertisers. This parallels the benchmark case where the description contributes context but no behavioral depth beyond safety annotations.

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

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

The description is a single front-loaded sentence with no wasted words. The leading verb and resource are clear, and the following colon-led list is informative without being excessive. Every part of the sentence contributes to understanding.

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

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

While the tool is read-only with a rich schema and output schema, the description does not explain how to choose between the `catalog` parameter and the free-form `parameters` object, nor does it mention that some catalogs may require `advertiserId` or `query`. Given the nested objects and 17 enum values, the description alone is too sparse for fully confident invocation, though annotations and schema partially compensate.

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 description does not elaborate on any parameters, such as how `query` or `parameters` interact with a chosen `catalog`. It provides no additional meaning beyond what the schema already documents.

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

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

The description uses the specific verb "Read" plus a clear resource (“targeting and planning catalogs”) and enumerates the catalog contents (locations, languages, interests, behaviors, hashtags, etc.). This is distinctive enough to separate it from sibling tools like tiktok_get_targeting or tiktok_search_keywords, since it focuses on dictionary/catalog data rather than account or campaign records.

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

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

The description implies that this tool is used when an agent needs to inspect or validate targeting catalog values, but it never explicitly states when to choose this tool over alternatives such as tiktok_get_targeting or tiktok_search_keywords. There are no when/when-not conditions or references to sibling tools, so the guidance is only 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?

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint, but the description adds useful behavioral context beyond those flags: the result is only ready once positive duration and dimensions exist, and the call does not upload again. This helps set expectations for polling or post-upload checks. No contradiction with annotations.

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

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

The description is three short sentences with no filler: purpose, readiness behavior, and non-upload clarification. The core identity is front-loaded, and every sentence contributes useful information.

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

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

For a two-parameter read-only tool with full schema coverage, rich safety annotations, and an output schema, the description is complete. It tells the agent what is read, when the result is ready, and what the call does not do, leaving no essential operational gap.

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

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

The input schema fully describes both parameters (advertiserId and videoId) with 100% coverage, so the description does not need to repeat their meaning. It also adds no additional parameter-level nuance, which is acceptable given the schema's clarity.

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 action and resource: 'Read one uploaded video from this advertiser’s media library.' It clearly signals a single-item read rather than a list or upload, which helps distinguish it from tools like tiktok_list_ad_videos, although 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?

The readiness condition ('Returns ready only after its media information is available with positive duration and dimensions') implies this tool should be used to check an uploaded video after processing. However, it does not explicitly say when to choose this over similar video-related siblings, so the guidance remains implied rather than explicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds some behavioral context by naming the underlying endpoints and suggesting conditional availability ('when available'), but it does not describe edge cases like empty results or error behavior.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It immediately states the action and resource, making it efficient for an agent 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?

While the output schema covers return shape and annotations cover safety, the description lacks guidance on how this tool relates to sibling asset-listing tools and what 'ad-linked' specifically means in terms of linkage (e.g., via adIds vs videoIds). This leaves some ambiguity for an agent selecting among similar tools.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description does not add any parameter-level semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states a specific verb ('Return') and resource ('ad-linked TikTok video asset metadata') from named endpoints. It is distinguishable from many siblings by emphasizing 'ad-linked' and 'video asset metadata', but it does not explicitly name alternative tools or contrast with them.

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

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

The description provides no explicit guidance on when to use this tool versus the many sibling tools (e.g., tiktok_list_ad_videos, tiktok_get_asset_urls). 'When available' hints at a condition but does not explain the intended use case or exclusions.

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

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

Annotations already cover readOnly, idempotent, openWorld, and non-destructive behavior. The description adds useful context about what is read (entity, parent settings, currency/timezone) beyond the annotations, which is valuable for agents deciding whether to call this tool. No contradictions with 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?

A single, front-loaded sentence with zero redundancy. It states the purpose and usage context efficiently without wasting words.

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

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

Given an output schema exists and annotations cover safety, the description is sufficient. It clearly explains the purpose, usage timing, and scope of what is read, so an agent has everything needed 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 coverage is 100% per context signals, so the schema fully documents all four parameters. The description does not add syntax or format details beyond what the schema provides, so a 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?

The description clearly states the tool reads the exact TikTok entity, parent settings, and advertiser currency/timezone, which is a specific verb+resource. It also frames it as a pre-write step ('before editing or building'), distinguishing it from general read tools among the many get_* siblings.

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

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

It gives a clear usage context: 'before editing or building a new configuration.' This implies when to use it, but it does not explicitly name alternative tools or state when not to use it, falling short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds a valuable security guarantee—'Never returns tokens or secrets'—which goes beyond the annotations and provides critical behavioral context for an agent handling credentials. It does not contradict 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, front-loaded sentences with zero filler. The core purpose ('Read-only health check') leads immediately, and the security note is a concise addition. Every word earns its place.

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

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

Given the low complexity (one optional parameter), existing output schema, and annotations covering safety, the description is complete. It tells the agent what the tool checks and what it guarantees not to return, leaving no critical gaps 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% for the single optional parameter, so the schema fully documents advertiserId, including its default behavior. The description adds no additional parameter-level detail, which matches the baseline for full schema coverage.

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

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

The description clearly states a specific verb ('health check') and resource (TikTok credentials, accessible advertisers, and advertiser info). It distinguishes itself from sibling data-retrieval tools by framing it as a diagnostic check, not a data pull. The purpose is unambiguous.

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

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

The description implies usage as a verification/health-check tool but does not explicitly state when to use it versus alternatives (e.g., tiktok_list_advertisers or tiktok_get_advertiser_info). No exclusions or conditional guidance are provided, leaving the agent to infer its role from the 'health check' label.

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. The description adds valuable behavioral context beyond this: image URLs are publicly served and signed for about thirty days, with the exact expiration provided via image_url_expires_at. This informs the agent about time-sensitive data without contradicting 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?

The description is a single, compact sentence that front-loads the primary action and resource, then adds the most critical return fields and URL expiry behavior. Every clause earns its place, with no filler or redundancy.

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

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

Given an output schema exists, the description adequately covers what an agent needs to know: the resource scope, pagination hints through 'whole library', and the time-sensitive nature of the URLs. It is complete for a read-only list operation with three well-documented parameters.

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 parameters (advertiserId, page, pageSize) are already well documented. The description does not add parameter-specific semantics beyond noting it lists the 'whole' library, which implicitly suggests pagination is relevant. Baseline 3 is appropriate because the schema carries the parameter meaning.

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

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

The description states a specific verb ('List'), resource ('advertiser's whole image library'), and enumerates the exact fields returned (file name, dimensions, signature, carousel usability, signed URL). This clearly distinguishes it from sibling tools like tiktok_list_ad_videos and tiktok_get_video_assets, which target different asset types.

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 clearly implies when to use it: when the agent needs the advertiser's full image library, including all categories (file/image/ad/search). It does not explicitly name alternatives or state exclusions, but the context is clear enough for an agent to select it over video-focused siblings.

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, openWorldHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds useful behavioral context about token scoping ('accessible with the current token') and the returned fields. It does not describe pagination or error behavior, but those are less critical given the strong annotation coverage and presence of an output schema.

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

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

Two short sentences deliver purpose, scope, and return fields with no filler. The main action and scope are front-loaded, and every word contributes meaning.

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 zero-parameter, read-only list operation with annotations and an output schema already present, the description covers what an agent needs: what is listed, token scoping, and the returned fields. No prerequisites or missing caveats are needed for correct invocation.

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

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

The input schema has zero parameters and schema coverage is 100%, so there is no parameter ambiguity for the description to resolve. The description appropriately says nothing about parameters, and the 0-param baseline of 4 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 the specific verb 'List all' with a clear resource ('TikTok advertiser accounts') and a scope constraint ('accessible with the current token'). It also states the exact returned fields (advertiser ID, name, status), making the tool's purpose immediately distinguishable from siblings like tiktok_get_advertiser_info.

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

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

The description implies the right use case: when an agent needs the full set of advertiser accounts under the current token. However, it does not explicitly mention when to prefer this over sibling tools like tiktok_get_advertiser_info or asset-listing tools, nor does it name any exclusions or alternatives.

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

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

Annotations already mark this as read-only, idempotent, and non-destructive. The description adds substantial behavioral facts beyond that: URLs are signed, expire after roughly six hours, need re-resolving, and the response includes publicly served preview/cover URLs. This is exactly the kind of non-obvious behavior an agent needs to know.

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 no filler: the first states the scope and returned fields, the second delivers the critical expiry caveat and the follow-up action. It is front-loaded and every sentence carries value.

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

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

With an output schema present and only three well-documented parameters, the description covers what an agent needs to invoke the tool correctly. It explains the response's notable fields and the URL re-resolution requirement, so there are no critical gaps.

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

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

The input schema already documents all three parameters with 100% coverage, including pagination bounds and defaults. The description adds no parameter-specific meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description names a specific action (list), a clear resource (the advertiser's whole video library), and enumerates the returned fields (file name, duration, dimensions, signature, preview/cover URLs). It is distinct from list-type siblings such as tiktok_list_ad_images because it is explicitly about videos and the full library scope.

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 establishes clear operational context: this returns the full video library and the URLs must be re-resolved via tiktok_get_asset_urls before use because they expire in about six hours. It does not explicitly contrast with siblings such as tiktok_get_video_assets or tiktok_get_uploaded_video, so it stops short of a full 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it is a safe read operation. The description adds that it returns recommended keywords with volume estimates, which is useful but not extensive. There is no contradiction, and the annotation coverage means the description doesn't need to carry the full burden.

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 no redundancy. The purpose is front-loaded, and the return detail is stated succinctly. Every word earns its place.

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

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

With a rich annotation set covering safety and idempotency, a complete parameter schema, and an output schema (has_output_schema=true), the description covers the core purpose and return shape. It doesn't mention any prerequisites or caveats, but given the overall context, nothing critical is missing.

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

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

Schema description coverage is 100%, so all three parameters (advertiserId, keywords, limit) are already documented in the schema. The description adds no extra parameter-level semantics beyond what the schema provides, so a 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?

The description states a specific verb (get), resource (keyword suggestions), and context (TikTok Search Ads), plus the return value (keywords with search volume estimates). It is unambiguous and distinct from the many sibling tools, which are all about audiences, ads, campaigns, or reports.

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

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

The description implies this is for generating keyword suggestions but does not explicitly state when to prefer it over alternatives or when not to use it. No exclusions or alternative tool references are given, leaving the agent to infer the context from the tool name and description.

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 and idempotentHint=true, so safety is covered. The description adds useful behavioral context about the validation logic (dimension grouping, lifetime compatibility) and that it is a pre-execution step. This goes beyond annotations without contradicting them.

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

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

The description is a tight two-sentence structure with the primary purpose front-loaded. Every sentence adds distinct value with no redundancy 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?

With an output schema present, return values need not be explained. The description covers purpose, timing, and validation scope, which is sufficient for an agent to decide when to call it. It does not detail failure behavior or prerequisites, but these are likely covered by the output schema and annotations.

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

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

Schema description coverage is 100%, so all five parameters are documented in the schema. The description does not add parameter-specific semantics beyond what the schema provides; it only references the metric/dimension combination generically. This meets the baseline for high coverage.

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

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

The description clearly states the tool's purpose: validating a TikTok metric/dimension combination before executing. It specifies what is checked (dimension grouping rules, lifetime compatibility, metric/dimension compatibility), which distinguishes it from all sibling tools that fetch data rather than validate.

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 indicates usage context with 'BEFORE executing', implying it should be used prior to query tools like tiktok_get_insights or tiktok_get_report_raw. However, it does not explicitly name alternatives or provide when-not-to-use guidance, leaving some inference to the agent.

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