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

With no annotations, the description carries the burden of disclosing behavior. It does disclose the kind of returned data (targeting, budget, optimization goal, schedule info), which is useful, but it does not mention read-only safety explicitly, pagination behavior, or any side effects. 'List' implies a read operation, so it is not misleading, just incomplete.

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 concise sentence that states the primary action and the key returned data. It is front-loaded and readable, though it could add a brief usage hint without much bloat.

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 straightforward listing tool with one required parameter and no output schema, the description gives the essential return contents. However, it lacks any indication of pagination limits, sibling distinctions, or prerequisites, so an agent might not know when this tool is the right choice among the many similar TikTok list tools.

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

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

Schema coverage is 67%, with advertiserId and campaignId documented in the schema; the limit parameter has no description but has clear default/min/max values. The description adds only marginal semantic value by clarifying the scope ('for a TikTok advertiser'), which aligns with advertiserId, but does not explain campaignId filtering or limit 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 clearly states the action ('List') and the resource ('ad groups for a TikTok advertiser'), and specifies the returned information. It is distinct from siblings like tiktok_get_campaigns and tiktok_get_ads, but does not explicitly contrast itself against them in the description.

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 descrption provides no guidance on when to use this tool vs the many sibing list tools (e.g., tiktok_get_campaigns, tiktok_get_ads). No exclusions or alternative routes are mentioned, leaving the agent to infer from the word 'ad groups' 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?

With no annotations supplied, the description carries the full burden of behavioral disclosure, but it only reports return fields. It does not address pagination semantics around the limit parameter, filtering behavior, rate limits, permissions, or what 'operation status' values look like; at best 'List' implies a read-only operation.

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-load the action and scope with zero filler. The return-field clause earns its place by previewing output, though it stays brief.

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?

Adequate for a simple 3-parameter list call: an agent can invoke it with just advertiserId and know the main output fields. But with no annotations and no output schema, the absence of pagination detail, the behavior of the adgroupId filter, and the meaning of 'operation status' leaves some inference required.

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 67% (advertiserId and adgroupId are documented); the description reinforces that the call is scoped to a single TikTok advertiser. However, the limit parameter is undocumented in both schema and description, and the description adds no filter or pagination meaning beyond what the schema already states.

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

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

Names a specific verb ('List') and resource ('ads for a TikTok advertiser') and previews key return fields (ad ID, name, operation status, creative info). The entity level is clear enough to suggest a hierarchy position next to the campaigs/adgroups/creatives siblings, though 'creative info' is vag and overlaps conceptually with tiktok_get_creatives, and no explicit contrast is drawn.

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

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

No guidance on when to use this versus the many list-type siblings (tiktok_get_campaigns, tiktok_get_adgroups, tiktok_get_creatives, tiktok_list_advertisers). The description just states what it does; any when-to-use signal is purely implied and no exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the behavioral burden. It clearly signals a read-only operation through 'Get' and enumerates the returned fields, which is useful. However, it does not disclose error behavior, authorization requirements, rate limits, or output envelope details.

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 efficient sentence with the action, target, and key output fields front-loaded. There is no filler or redundant terminology.

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 required parameter, no nested objects, and no output schema—the description provides enough to invoke the tool: it identifies the operation, the resource, and the primary return fields. It could be more complete by suggesting related tools for obtaining advertiser IDs, but that is a minor 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 sole parameter advertiserIds is already fully documented in the schema ('One or more advertiser IDs'). The description adds little beyond restating that the call targets advertiser accounts, so it does not meaningfully improve parameter understanding.

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 ('Get') and resource ('TikTok advertiser accounts') and lists concrete return fields: currency, timezone, status, balance. The word 'specific' distinguishes it from listing siblings like tiktok_list_advertisers, though it does not explicitly name an alternative.

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

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

There is no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as tiktok_list_advertisers for first obtaining advertiser IDs. The 'specific' wording loosely implies the agent should already have IDs, but this is not developed into actionable 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explicitly states no mutation is performed, which is valuable, but it does not mention required auth/scope, polling behavior, or what a response contains. The read-only claim is clear but incomplete.

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 first, and the anti-mutation clarification is a necessary second sentence. 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?

The tool is simple, with two fully documented parameters, and the description accurately conveys the operation. However, there is no output schema and the description does not explain what status values are returned or whether repeated polling is expected, so the agent lacks full information for a 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 coverage is 100%, giving a baseline of 3. The description adds semantic value beyond the schema by explaining that taskId comes from a TikTok report task creation outside this MCP, which clarifies where the ID originates. advertiserId is not enriched, but the provenance detail tips it slightly above 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 names a concrete operation (check status), the resource (TikTok async report task), and the key identifier (taskId). It does not explicitly differentiate from sibling tools like tiktok_get_report_raw, but the 'No report creation or mutation' phrase narrows the purpose.

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

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

The phrase 'when async report endpoints are available' gives some context and 'No report creation or mutation' implies it is for checking an already-created task. However, no alternative tool is named and there are no explicit when-to-use/when-not-to-use conditions relative to the many read-only 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?

Since no annotations are provided, the description carries the full behavioral burden. 'Read-only only' is a genuine safety disclosure that tells the agent this call does not mutate state, and 'where TikTok DMP endpoints are accessible' hints at an availability constraint. However, it does not explain failure modes, what happens when endpoints are inaccessible, pagination, or rate-limit behavior.

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

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

Two short sentences with the verb+resource front-loaded and no filler. 'Read-only only' is slightly redundant with 'Get' but functions as deliberate safety emphasis; the 'where TikTok DMP endpoints are accessible' clause is vague but costs little.

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?

No output schema exists, so the description should convey return shape, but it does not. It also fails to route among audience-related siblings and never explains what 'DMP endpoints accessible' means or how an agent should respond when the condition does not hold. For a tool with no annotations and 27 siblings, this is incomplete.

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 75%, so the schema already documents advertiserId, audienceIds, and includeSavedAudiences. The description reinforces the audience-type scope, which maps to audienceIds and includeSavedAudiences, but it adds nothing about the undocumented 'limit' parameter, including its pagination semantics.

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 ('custom/lookalike/saved audience details'), clearly identifying what the tool fetches and scoping it to three audience types. It does not explicitly differentiate from siblings like tiktok_get_audiences or tiktok_get_audience_overlap, and the 'where TikTok DMP endpoints are accessible' qualifier adds a scope caveat without clarifying it.

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

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

No guidance on when to choose this tool over the 27 siblings, including the closely related tiktok_get_audiences, tiktok_get_audience_overlap, and tiktok_get_targeting_catalog. The DMP-accessibility caveat implies availability limits but offers no decision rule, prerequisites, or alternative routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does disclose the read-only nature, establishing the absence of mutations—a meaningful safety signal. However, it does not explain parameter-driven behaviors such as overlapThreshold semantics, includeSavedAudiences impact, or the shape of returned diagnostics, leaving significant behavioral gaps.

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, polished sentence with the key read-only qualifier front-loaded and entity types listed compactly. Every word earns its place, with no repetition or fluff.

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 6-parameter diagnostic tool with no annotations and no output schema, a one-sentence description is insufficient. It omits the meaning of overlapThreshold, default limits, the relationship between adgroupIds and campaignId filters, and expected output structure. Agents would need to rely on schema defaults and external knowledge to invoke this correctly, which is a significant completeness gap.

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

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

Schema descriptions cover only adgroupIds, campaignId, and advertiserId; limit, overlapThreshold, and includeSavedAudiences lack schema documentation. The description adds meaning by naming the audience entities and targeting fields, but it does not clarify the numeric threshold, limit behavior, or the saved-audience inclusion flag. With 50% coverage, the description only partially compensates for what the schema leaves undocumented.

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 the tool's scope as 'read-only audience overlap diagnostics' and enumerates the entities it spans (ad groups, custom audiences, saved audiences, targeting fields), clearly distinguishing it from sibling tools like tiktok_get_audiences and tiktok_get_audience_details. It lacks a concrete action verb, but 'diagnostics' combined with the tool name implies retrieval or analysis. Not a tautology and genuinely informative.

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. The description does not name alternatives, exclusion criteria, or conditions that would make a different tool more appropriate. An agent must infer usage solely from the tool name and one phrase, which is minimal 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?

With no annotations present, the description carries the full burden of behavioral disclosure. The verb 'List' clearly implies a read-only operation, but the description does not mention pagination, response shape, or whether the result includes all votes or is limited by the 'limit' parameter.

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, 11-word sentence with no filler. It earns every word by stating the action, resource type, and scope 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 simple list tool with only two parameters, this is minimally adequate: an agent can infer the required advertiserId and the general purpose. However, it omits usage guidance and does not clarify the semantics of the 'limit' parameter, leaving clear but non-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?

Schema description coverage is only 50%, and the description adds little parameter meaning beyond the schema. It does not explain that 'advertiserId' is the required account identifier beyond the obvious scope reference, and it does not clarify that 'limit' controls the number of returned audiences or pagination 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 names a specific verb ('List'), a clear resource ('custom and lookalike audiences'), and a scope ('for a TikTok advertiser account'). It clearly conveys what the tool does, though it does not explicitly differentiate itself from siblings like tiktok_get_audience_details.

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_audience_details or tiktok_get_audience_overlap. The intended use is only implied by the phrasing 'List...', with no explicit when/when-not or alternative routing.

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

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

With no annotations provided, the description carries the full burden. It discloses the read-only nature ('List') and enumerates returned fields, which is helpful. However, it does not address pagination behavior, the effect of statusFilter, rate limits, or authorization requirements, leaving some behavioral ambiguity.

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 that states the action, scope, and key return fields with no filler or redundancy. Every clause adds 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?

The core purpose and return fields are given, which is sufficient for a simple list tool at a basic level. However, the absence of an output schema and annotations means the description should offer more context about pagination, filter behavior, and result structure; these gaps prevent the definition from being fully self-sufficient.

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 only 33%, and the description does not compensate. AdvertiserId is described in the schema, while limit and statusFilter have no additional explanation in the description beyond their schema types/defaults/enum. The description's mention of 'status' in the return fields is not tied to the statusFilter parameter, so parameter semantics are underspecified.

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

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

The description uses a specific verb 'List' and a clear resource 'campaigns for a TikTok advertiser account', and lists the return fields (ID, name, status, budget, objective). It is clear and unambiguous, though it does not explicitly distinguish itself from sibling tools like tiktok_get_adgroups or tiktok_get_ads.

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

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

The description implicitly signals when to use this tool (when you need campaign-level data for an advertiser account), but provides no explicit guidance about alternatives, prerequisites beyond the advertiser ID, or conditions when another tool should be used instead. The usage context is implied rather than stated.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly states the operation is read-only and 'Does not create, edit, or upload creatives,' which is valuable transparency. It does not discuss permissions or rate limits, but for a non-mutating analysis tool this is largely sufficient.

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 tightly written sentences: the first states purpose and output, the second reinforces read-only safety. No filler or repeated schema information, and the most important detail is 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?

The tool has six parameters, no annotations, and no output schema, yet the description only explains the high-level purpose and read-only nature. It does not describe the shape of a 'recipe,' the meaning of the threshold parameters, or any analysis-specific behavior. The schema covers some inputs, but the missing output context leaves an agent under-informed about what to expect.

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 50%, and the description itself adds no parameter-level meaning. The schema documents advertiserId, startDate, and endDate, but limit, minImpressions, and declineThresholdPct are only inferable from their names and numeric ranges. The description neither compensates for nor clarifies these gaps, landing at 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 uses a specific verb and resource: 'Find likely creative fatigue patterns from ad-level daily reporting' and clarifies the output as 'read-only refresh recipes.' It is clearly distinct from sibling tools like tiktok_get_creatives or tiktok_get_insights, which fetch raw data rather than fatigue analysis.

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 makes the primary use case clear: use this when you need creative fatigue patterns and refresh recommendations. It does not explicitly name alternatives or state when not to use it, so it stops short of a 5, but the context is strong enough for an agent to route correctly.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It indicates a read operation but does not clarify that adIds is optional in the schema, what happens when it is omitted, pagination/limit behavior, or the shape of the returned creatives. The phrase 'for specific ads' could mislead an agent into assuming adIds is required.

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 leads with the action and resource, then adds scope and content-type detail. Every word contributes to the core purpose, making it 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?

Given no output schema, no annotations, and a large sibling set, the description is too thin for confident invocation. It omits return-value expectations, limit semantics, optionality behavior, and any routing hints to related creative/video tools, leaving important operational 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 schema already documents advertiserId and adIds; the description adds little parameter-level meaning and does not address the undocumented limit parameter. The phrase 'for specific ads' roughly aligns with adIds, but the optionality of adIds is not surfaced, making the parameter semantics only partially helpful.

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 ('creative details'), and content types ('video, image, text'), with an advertiser-account scope. This is enough to distinguish it from sibling tools like tiktok_get_ads or tiktok_get_video_assets, even though it does not name alternatives explicitly.

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

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

The implied usage is clear: use this tool when creative details for selected ads are needed. However, the description gives no explicit guidance about when to prefer this tool over siblings, nor any exclusion criteria, leaving the agent to infer routing from the tool name and minimal context.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It adds only 'aggregate' and 'simple diagnostics' beyond the tool name. It does not explain how limit affects results, what operation_status values mean, how filters are applied, or whether the aggregated result is a summary or a detailed list.

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 tight sentence with no filler and the key concept 'Aggregate' is front-loaded. It earns a 4 because it is concise and scannable, though 'simple diagnostics' is slightly 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?

With no output schema and no annotations, an agent needs more context about what the aggregated status response looks like and how filters combine. The description does not cover pagination, default ad-level inclusion, return shape, or diagnostic semantics. This is insufficient for confident invocation in non-trivial cases.

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 80%, so the baseline is 3 and the description does not need to restate parameter meanings. Still, the description adds no extra semantics for how campaignId, adgroupId, or includeAds affect aggregation behavior. The limit parameter is undocumented in both the schema and the description.

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 ('Aggregate') and names the exact resource scope ('campaign, ad group, and ad delivery status/operation_status'). It distinguishes itself from sibling per-level getters like tiktok_get_campaigns and tiktok_get_ads by signaling cross-level aggregation. 'Simple diagnostics' is somewhat vague but does not obscure the core 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 word 'Aggregate' implies this tool is for retrieving status across multiple entity levels at once, which is a useful hint against the sibling per-entity tools. However, it never names alternatives or states when not to use this tool. Usage guidance is present only implicitly.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It explicitly states GET-only and labels itself an escape hatch, signaling read-only behavior and raw/uncurated output. It does not discuss error behavior, response format, or rate-limit implications, but the core safety profile is clear.

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

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

Two sentences, no filler, and the most important information is front-loaded: what the tool lists and how it is parameterized. The second sentence earns its place by clarifying why this raw tool exists relative to curated alternatives.

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 raw list tool, this description covers the essential selection criteria and purpose well. However, with no output schema and no annotations, it leaves the native response shape and raw-endpoint caveats implicit, and it does not spell out the relationship to sibling tools beyond the vague 'curated schemas' reference.

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 only 13%, so the description must compensate. It does by mapping 'caller-selected native fields' to fields, and 'filtering, sorting, pagination' to filtering, orderField/orderType, and page/pageSize. It does not explain exact syntax or constraints, but it gives enough semantic grounding to understand each parameter group.

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

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

The first sentence names a specific verb ('List') and a specific resource class ('TikTok campaigns, ad groups, or ads'), and defines scope with caller-selected fields, filtering, sorting, and pagination. The second sentence distinguishes this as a raw, GET-only escape hatch versus the MCP's curated schemas, which clearly sets it apart from the curated sibling tools.

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

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

The phrase 'escape hatch' and 'without waiting for the MCP's curated schemas' gives an explicit when-to-use: use this when you need newly released entity fields before curated schemas are available. It does not explicitly say 'use the curated get_* tools for stable fields,' so it stops short of a full when-not-to-use statement.

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

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

With no annotations, the description must carry behavioral disclosure itself. It does reveal an important trait: 'best-effort endpoint checks plus reporting dimensions as fallback', which signals the tool may not return results from a single clean endpoint. It does not state read-only status, failure modes, or permission implications, but the get/discover framing implies a non-mutating operation.

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 concise sentences with no filler. The main purpose is front-loaded, and the second sentence adds meaningful fallback behavior without redundancy.

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

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

The description is reasonably complete given that the schema covers most parameters, but the absence of an output schema and annotations increases the burden on the description. It does not clarify what the returned event/diagnostics data contains or how the optional bcId/appId/pixelId paths affect results, leaving some ambiguity for an agent deciding whether this tool is the right one.

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 86%, so the input schema already explains most parameters and the baseline is 3. The description adds context by mentioning 'pixel/app events' and 'tracking diagnostics', which aligns with pixelId/appId and date parameters, but does not materially expand on the schema's parameter semantics.

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 ('Discover') and a resource ('pixel/app events or accessible tracking diagnostics for an advertiser'), which distinguishes it from tools like tiktok_get_pixels and tiktok_get_insights. However, 'events' and 'tracking diagnostics' remain somewhat underspecified, so it stops short of fully precise.

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

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

Usage is implied: use this tool when you need pixel/app events or tracking diagnostics. There is no explicit guidance on when to prefer it over related tools such as tiktok_get_pixels or tiktok_get_insights, and no when-not-to-use conditions.

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

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

With no annotations, the description carries the transparency burden and does disclose a key runtime behavior: the query planner automatically splits incompatible dimension combinations with the one-ID-plus-one-time-dimension rule. It also notes 400+ metric support, but does not mention authentication, rate limits, or response format, so it is not fully exhaustive.

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

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

Three short sentences with no filler. The main action is front-loaded, followed by resource pointers and the most important planner behavior. Every sentence adds 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?

The description covers metric discovery and the planner rule, which are important for correct invocation, and the schema covers most parameters. However, with no output schema and no mention of pagination, result shape, date-range limits, or when to prefer this over the raw report endpoint, an agent still has to infer some operational details.

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 75%, so most parameters like metrics, dimensions, dates, advertiserId, and queryLifetime already carry clear meaning in the schema. The description adds one useful cross-parameter constraint about dimension compatibility and auto-splitting, but does not explain dataLevel or limit beyond what the schema provides.

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 the core action ('Query TikTok Ads performance insights') with a specific resource and adds 'Supports 400+ metrics' and query planning, giving it a clear identity. It does not explicitly differentiate from reporting siblings like tiktok_get_report_raw, but the metrics/dimensions resource links make the purpose 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 provides practical context by directing the agent to tiktok://metrics and tiktok://dimensions for discovering valid values, which implies how to prepare calls. It does not state when to choose this tool over sibling reporting tools such as tiktok_get_report_raw or tiktok_get_entities_raw, so alternatives and exclusions are missing.

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

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

With no annotations, the description carries the full transparency burden. It usefully discloses permission-gated event metadata and fallback with explicit warnings, but does not mention pagination, rate limits, required scopes, or failure modes beyond endpoint unavailability.

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 wasted words. The core action is front-loaded and the caveat about permissions and fallback is stated 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?

With no output schema and no annotations, the description explains the core listing purpose and fallback, but leaves the agent without details on return structure, pagination behavior, or how warnings are surfaced. It is adequate for a read-only listing tool but not fully complete.

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

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

Schema description coverage is 80%, so parameter meanings are mostly already documented. The main description adds little beyond what the schema provides; the discovery logic it references is already captured in the pixelIds parameter description.

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 ('List') and resource ('TikTok pixels'), and adds that pixel event metadata is included when permissions allow. This distinguishes it from sibling tools like tiktok_list_advertisers or tiktok_get_events, though it does not explicitly name any alternative.

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

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

No guidance about when to prefer this tool over siblings or when it should not be used. The only usage-related hint is the fallback behavior when endpoints are unavailable, which is more behavioral than a selection criterion.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does well by stating that only GET requests are allowed, that relative v1.3 paths and JSON-compatible query parameters are validated, and that several risky categories are blocked. It does not mention error behavior or response format, but the main safety-relevant behaviors are transparently disclosed.

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 only two sentences and front-loads the core purpose and key behavioral constraints. It is efficient and well structured, though the word 'Advanced' adds little and could be removed without losing 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 generic escape-hatch tool with two parameters and no output schema, this description is reasonably complete. It tells the agent when to use the tool, what constraints apply, and what is blocked. The absence of explicit guidance on response shape or error handling is a minor gap given the raw-endpoint nature of the tool.

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

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

Schema description coverage is 50%, with the endpoint parameter documented but the parameters object undocumented. The description adds useful meaning by explaining that endpoints are relative v1.3 paths and that parameters are treated as JSON-compatible query parameters. However, it does not fully compensate for the undocumented parameters object, leaving room for ambiguity about how nested or complex parameter values are handled.

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 identifies this as a GET-only escape hatch for TikTok Business API read endpoints not covered by specialized MCP tools. It names the verb, resource, and precise scope, and the phrase 'not yet modeled by a specialized MCP tool' distinguishes it from the many sibling tools.

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

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

The description explicitly states when to use it: for documented JSON read endpoints that do not yet have a specialized MCP tool. It also states what is blocked (OAuth, mutations, downloads, lead-record paths), giving clear exclusions. However, it does not name a specific alternative tool to use instead, so it falls slightly short of the strongest possible 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?

With no annotations present, the description carries the full burden of behavioral disclosure. It does reveal meaningful traits: the report is synchronous, native, does not compute aliases, and does not auto-split incompatible selections, which are important operational nuances. However, it does not disclose return format, pagination behavior, potential errors, rate limits, or permission expectations, leaving notable behavioral gaps.

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

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

The description is two sentences with no fluff. The core action is front-loaded, and the second sentence adds a use condition and sibling distinction. Every sentence earns its place, and the structure makes the purpose and differentiation immediately obvious.

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 14-parameter raw reporting tool with no annotations, no output schema, and 0% schema description coverage. The description provides the why and a sibling comparison, but it omits almost everything an agent would need to assemble a correct request: meaning of report types, data levels, date formats, filtering syntax, pagination limits, and expected response behavior. It is not complete enough for the complexity involved.

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 0%, so the description must compensate for the 14 parameters, but it only acknowledges 'caller-selected dimensions and metrics.' It provides no explanation of reportType, serviceType, dataLevel, filtering, orderField, pagination, or the other parameters. This is insufficient for a tool with this many inputs and enums.

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 starts with a specific verb and resource: 'Run a native TikTok synchronous report.' It further clarifies that dimensions and metrics are caller-selected, and explicitly contrasts itself with the sibling tiktok_get_insights by noting that it does not calculate aliases or auto-split incompatible selections. This makes the purpose unambiguous and distinguishes it from nearby tools.

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

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

The description gives a concrete usage trigger: 'Use when a current API field is not yet in tiktok://metrics.' It also names the alternative tiktok_get_insights and states a key behavioral difference, so an agent can decide when this raw native report is preferred over the more abstracted insights call. This is explicit and actionable.

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?

Without annotations, the description carries the behavioral burden. It does state 'Read-only diagnostics only,' which is useful and prevents assumptions of mutation. But it does not explain how maturity is derived, whether multiple endpoints are called, or any rate-limit/auth implications, so transparency is only partial.

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

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

Two short sentences, front-loaded with the core purpose. The 'read-only diagnostics only' phrase adds safety context without wasting space. Every clause earns its place.

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

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

The description lacks operational context: no return format, no explanation of what 'maturity' means or how to interpret the result, and no mention of the required advertiserId or date defaults. With no output schema and six parameters, this is a significant gap for an un-annotated tool.

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

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

Schema description coverage is 67%, so most parameters are already documented. The description adds some meaning by connecting seedKeywords to 'optional keyword recommendation endpoints' and implying date parameters bound reporting. It does not substantially clarify limit or dataLevel beyond what the schema/enum provides.

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 ('Diagnose') and resource ('TikTok Search Ads maturity'), and identifies the data sources. It is clearly distinct from the many generic tiktok_get_* sibling tools. The term 'maturity' is somewhat vague, and no sibling comparison is made, so it falls short of a perfect 5.

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

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

Usage is implied: use this when you need to diagnose TikTok Search Ads maturity. However, the description does not explicitly say when NOT to use it, nor does it name alternatives or exclusions, leaving routing decisions 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the operation is read-only, describes the endpoint fallback order (catalog reporting first, then Shop auction metrics), and discloses that warnings are returned when catalog permissions are unavailable. This is meaningful behavioral transparency beyond the basic 'get' operation.

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, information-dense sentence with no filler. The core purpose is front-loaded, and every clause adds value: read-only safety, endpoint attempt order, and warning behavior.

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

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

For a 9-parameter tool with no annotations and no output schema, the description gives useful behavioral context but lacks response format expectations, param selection guidance, and clearer failure semantics. The fallback warning detail helps, but an agent would still need to infer much from the schema and runtime results.

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 78%, so most parameters are already documented in the schema. The tool description itself adds no parameter-level meaning beyond the schema. The 22% gap is minor, but the description does not compensate for it; 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 identifies the tool as read-only TikTok Shop/catalog/e-commerce diagnostics with a specific resource and action. It does not explicitly differentiate from siblings like tiktok_get_targeting_catalog or tiktok_get_report_raw, but the 'diagnostics' framing and catalog/Shop scope make the purpose reasonably distinct.

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 a general context (TikTok Shop/catalog diagnostics) but no explicit guidance on when to use this tool over alternatives, nor any exclusions or prerequisites. The fallback behavior is described, but not the conditions that should lead an agent to select this tool instead of a sibling.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does reveal that the tool has a 'conservative fallback' when Spark-specific fields are unsupported, which is a useful behavioral trait. However, 'conservative fallback' is undefined—an agent cannot tell whether that means empty results, partial fields, or an error—so the transparency is only partial.

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 main action, and contains no filler or redundant restatement of the tool name. The fallback behavior is included without bloating the text.

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

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

Given no output schema and no annotations, the description leaves too much unspecified: the response shape, the exact fallback behavior, how the optional filters interact, and what 'Spark Ads context' actually contains. An agent trying to call this tool correctly would need to infer or experiment to understand the return value and edge cases.

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 75%, but the description itself adds no parameter-specific meaning. It never mentions advertiserId, adIds, adgroupId, or limit, and the 'ad fields' phrase is too vague to clarify which parameters control the returned context. The one undocumented parameter (limit) is not compensated for by the description.

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 ('Spark Ads context') and action ('Return'), and adds the qualifier 'from ad fields when available.' It is not a tautology and is more specific than many sibling names, but it does not explicitly distinguish itself from the closely related sibling tiktok_get_spark_organic_joins.

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 about when to use this tool versus its many siblings, nor any mention of prerequisites or the conditions under which the fallback should be expected. The phrase 'when available' refers to data availability, not to user decision-making, so it does not help an agent choose between alternatives.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It does state 'Read-only only' and notes that organic endpoints are attempted conditionally on permissions, which are useful disclosures. However, it omits failure modes, return behavior, and what happens when optional endpoints are unavailable, leaving significant gaps.

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

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

The description is two short sentences, both informative: the core join action and the read-only guarantee. There is no filler or repetition. While it is terse, the efficient structure front-loads the primary purpose and a key behavioral constraint.

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

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

With no output schema and no annotations, the description needs to explain what the tool returns and when to apply it, but it does not. It also does not address the behavior of optional experimental endpoints, which are relevant because includeExperimentalEndpoints can return 404. Given the tool's complexity (8 parameters, 1 required), this is a significant completeness gap.

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

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

Schema description coverage is 88%, and most parameters already have clear descriptions in the schema. The tool description itself adds no parameter-level detail, only framing the overall join operation. A baseline score of 3 is appropriate because the schema does the heavy lifting for 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 ('Join') and names the resources involved: Spark Ads fields, paid page/post reporting, and optional organic identity/post endpoints. It clearly conveys a data-merging purpose, though it doesn't explicitly distinguish this from sibling tiktok_get_spark_ads. The 'Read-only only' qualifier adds a precise behavioral boundary.

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

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

There is no guidance on when to use this tool versus siblings like tiktok_get_spark_ads or tiktok_get_ads. The mention of 'when permissions allow' hints at conditional availability but does not state prerequisites, use-case criteria, or exclusions. An agent would have to infer the appropriate context from the name and parameter schema.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates read-only intent with 'Read,' but omits response shape, pagination, per-catalog behavior variation, whether advertiserId is needed, and any other operational details that matter for a generic endpoint wrapper.

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 entire description is one efficient sentence that front-loads the action and scopes the resource, then packs in the complete catalog inventory without filler. The length is justified by the need to enumerate many catalog types.

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 complex shape — a nested `parameters` object, no output schema, and many catalog-specific variants — yet the description only lists catalog names. It doesn't explain how to compose requests, when to supply `query`, what `parameters` should contain, or what the agent should expect back, making it insufficient for reliable 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 coverage is only 25%, and the required `catalog` parameter lacks a schema description. The description does add some value by translating catalog enum values into human-readable categories, but it says nothing about `query`, `parameters`, or `advertiserId`, so the agent is left guessing on most parameters.

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

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

Starts with a clear verb+resource ('Read TikTok targeting and planning catalogs') and enumerates the specific catalog categories, which maps closely onto the enum values. It doesn't explicitly distinguish itself from similar read endpoints like tiktok_search_keywords or tiktok_get_read_endpoint, so it stops short of a 5.

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

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

There is no guidance on when to choose this tool over sibling tools, no stated exclusions, and no mention of which catalog types work with which optional parameters. The only usage signal is an implicit 'if you need a targeting catalog,' which leaves appropriate selection 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that results come from two endpoints and are only returned 'when available,' but it does not explain what affects availability, how adIds and videoIds interact, whether this is strictly read-only, or what the response looks like. The caveat is too vague to be actionable.

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 with no filler and states the core action upfront. However, the phrasing 'ad/get and video material endpoints' is slightly awkward and 'when available' is vague, which keeps it from being exemplary.

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 there are no annotations, no output schema, and five parameters, this short description is incomplete. It omits return-value structure, parameter interaction, failure behavior, and any guidance on when data is unavailable. An agent would need to guess important calling conventions.

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?

Input schema coverage is high at 80%, so the schema already documents most parameters. The description adds minimal value beyond the schema, only clarifying the ad-linked/video material context. Since the schema carries most of the semantic burden, 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 clear verb ('Return') and a specific resource ('ad-linked TikTok video asset metadata'), and names the underlying source endpoints. It does not explicitly differentiate from siblings like tiktok_get_creatives, but the focus on video assets and ad linkage is reasonably distinct.

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

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

No guidance is given about when to use this tool versus alternatives such as tiktok_get_creatives or tiktok_get_ads. The description does not mention preferred scenarios, exclusions, or fallback tools, leaving the agent to infer use cases.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explicitly states the operation is read-only and guarantees it never returns tokens or secrets, which are material safety behaviors. It does not describe failure modes or response shape, but the key non-mutating and secret-handling traits are covered.

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

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

The description is two short sentences with no filler. The first sentence front-loads the operation and scope, and the second adds a concise security guarantee. 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?

For a low-complexity tool with one optional parameter, the description names the relevant objects and adds an important security guarantee. However, with no output schema, it stops short of indicating what a successful or failed health check returns, which is a notable gap for an agent invoking the 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 fully documents the single optional advertiserId parameter, including its fallback behavior from TIKTOK_ADVERTISER_ID to the first accessible advertiser. Since schema coverage is 100%, the description does not need to add parameter detail, 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 states a specific diagnostic operation ('health check') and names the exact resources involved: TikTok credentials, accessible advertisers, and advertiser info. This clearly differentiates it from the many get_* sibling tools, which fetch specific data rather than check overall health.

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 phrase 'read-only health check' implies use for verifying TikTok access and advertiser availability, but no explicit when-to-use guidance, exclusions, or alternative tool comparisons are provided. The agent must infer the trigger condition 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?

No annotations are provided, so the description carries the full burden. It discloses the operation (read-only list), the authorization scope (current token), and the return fields (ID, name, status). It does not mention pagination or errors, but for a zero-parameter read-only listing tool this is adequately transparent.

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 wasted words. The action and scope are front-loaded, and the return fields are stated in a compact 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 zero-parameter listing tool with no output schema, the description is sufficient: it tells the agent what the operation is, what the result contains, and under which token scope. No essential calling detail is missing at this complexity level.

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

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

The tool has zero parameters, so the baseline of 4 applies. The description does not need to add parameter detail because there are no parameters to document; the schema coverage is effectively complete.

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 clear resource ('TikTok advertiser accounts accessible with the current token'), and enumerates the returned fields (ID, name, status). This clearly separates it from sibling tools like tiktok_get_advertiser_info, which implies retrieving a single advertiser's details.

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 is implied from the scope ('accessible with the current token') and the list operation, but there is no explicit guidance on when to use this instead of tiktok_get_advertiser_info or other siblings. It provides context but no 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?

No annotations are provided, so the description carries the full burden. It discloses the core behavior: returns recommended keywords with search volume estimates, and the read-only nature is strongly implied by 'Get' and 'Returns'. However, it does not disclose potential rate limits, pagination, or how the limit parameter affects results, so behavioral transparency is adequate but not rich.

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

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

The description is two short sentences with no filler. The main purpose is front-loaded, and the return value is stated immediately. 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?

For a simple, read-only suggestion tool, the description plus schema is mostly complete: required inputs are in the schema, and the description states the key return output. There is no output schema or annotations, so a bit more detail about the exact response shape would help, but the essentials are 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?

The schema already documents advertiserId and keywords, including that keywords are 'Seed keywords to get suggestions for', and limit has clear default/min/max constraints. The description adds no parameter-level detail, and with 67% schema coverage the description does not need to fully compensate, but it also does not enhance parameter understanding.

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

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

The description names a specific verb-resource pair: 'Get keyword suggestions for TikTok Search Ads', and states the concrete return value: 'recommended keywords with search volume estimates'. This clearly distinguishes it from sibling tools, which are mostly entity-listing or status/health endpoints.

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 phrase 'for TikTok Search Ads' gives implicit context about when the tool is relevant, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives. Since none of the siblings appear to offer keyword suggestions, the lack of explicit routing is minor but still only implied.

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

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

With no annotations provided, the description carries the full disclosure burden. It conveys that the tool is non-executing ('BEFORE executing'), that it only checks compatibility rules, and it lists the three validation categories. It does not disclose return format, error/failure behavior, or rate limits, which would strengthen it, but the core behavioral profile — validate, don't execute — is clearly conveyed.

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 front-loads the purpose and timing, the second lists the validation scope. Every clause contributes information, and the tool name is not merely restated.

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 defnition is adequate for a validation tool but has real gaps: no output schema exists, yet the description never says what the tool returns (e.g., boolean pass/fail, list of violations, or thrown error), so an agent cannot know how to interpret the result before proceeding. With no annotations and two undocumented parameters, some of that burden shifts to the description, and it does not fully carry 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 only 50%, with dataLevel and queryLifetime lacking schema descriptions. The description partially compensates by linking 'lifetime compatibility' to queryLifetime and 'metric/dimension combination' to the metrics/dimensions arrays, but it never addresses dataLevel's semantics or why the chosen level matters for validation. The added meaning over the schema is modest.

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 ('Validate'), a resource ('TikTok metric/dimension combination'), and the pre-execution role ('BEFORE executing'). It further enumerates the exact checks performed (dimension grouping rules, lifetime compatibility, metric/dimension compatibility), which clearly differentiates it from the many tiktok_get_* siblings that execute queries.

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

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

'BEFORE executing' gives clear contextual guidance on when this tool is needed — as a pre-flight guard before query tools like tiktok_get_insights or tiktok_get_report_raw. However, it does not explicitly name alternative tools or state when-not-to-use scenarios, so it stops 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.