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

Annotations already declare readOnly=false, destructive=false, openWorld=true. The description adds meaningful operational context beyond them: the schedule triggers autonomous agent execution, results/questions can be routed to Telegram, and a channel link must exist first. It does not discuss failure modes or what happens if the link is missing, but with annotations covering the safety profile this is solid.

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

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

Two tight sentences with no filler. The core creation action is front-loaded, followed by the scheduling mechanic and the Telegram prerequisite in priority order.

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

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

An output schema exists, so return values need no explanation, and annotations cover the safety profile. Combined with the prerequisite routing and scheduling semantics, the description is nearly complete, though it never addresses threadId, which is undocumented in both schema and description.

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 86%, so the baseline is 3. The description adds value beyond the schema by emphasizing the intervalMinutes OR cronExpr mutual exclusivity and the purpose of the prompt template as the recurring payload. It does not explain the otherwise-undocumented threadId parameter, leaving one semantic gap.

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 ('Create a recurring or one-off autonomous Super Agent trigger') and immediately explains the core mechanic: the agent runs the prompt template on the schedule via intervalMinutes OR cronExpr. This clearly distinguishes it from siblings like list_agent_schedules and pause_agent_schedule.

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

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

Explicitly covers the Telegram delivery path and its prerequisite ('link it first with create_channel_link_token'), naming the sibling tool to call before this one. It does not spell out when to choose recurring vs one-off or cron vs interval beyond the schema's OR constraint, so minor guidance is left 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 declare readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is covered; the description adds the genuinely new behavior that ingestion is asynchronous and must be polled. It also discloses what the crawl produces. It doesn't say whether a failed crawl leaves a partial brand, or whether re-creating with the same URL errors or duplicates.

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

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

Three short sentences, front-loaded with the action and its mechanism, then the async caveat, then the next step. No filler or restatement of the title.

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

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

An output schema exists, so return values needn't be explained, and the async behavior is called out. The one gap is that "poll the brand status" names no tool in a sibling list that contains get_brand, get_job and list_jobs, leaving the agent to guess which to poll.

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

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

Schema coverage is 100% with a single required `websiteUrl` that already carries a format and example, so the schema does the work. The description only characterizes the URL as "the site" to be crawled, adding no format or constraint detail beyond that.

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 ("Create a saved brand") plus the mechanism ("ingesting a website URL") and the derived artifact (brand DNA: logo, colors, tone, value props). This distinguishes it cleanly from read-side siblings like get_brand, list_brands and from the downstream generate_brand_video.

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

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

Gives clear post-call sequencing: "Ingestion runs in the background; poll the brand status" and "After it's ready, use generate_brand_video." What's missing is the negative case — it never says to use get_brand/list_brands instead when the brand already exists, so an agent could re-create a duplicate.

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

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

Annotations already establish that this is a non-read-only, non-destructive, closed-world operation. The description adds important behavioral context by saying the code is short-lived and must be sent to the Telegram bot, though it omits details like expiry duration or single-use 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 two tight sentences, front-loads the core action, and includes only useful workflow context. No sentence is redundant.

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

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

For a one-parameter tool with an output schema and clear annotations, the description is complete enough. It explains the purpose, the short-lived nature of the token, and the next action an agent should take.

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 only parameter, 'channel,' is fully documented in the schema with its default and Phase 1 scope. The description does not add meaning beyond the schema, so the baseline of 3 is appropriate for 100% 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 uses a specific verb, 'Generate,' and a specific resource, 'short-lived link code,' and explains its linking purpose with the Telegram bot. It is clearly distinct from sibling tools like list_channel_accounts.

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

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

It clearly states the usage context: send the code to the EzUGC Telegram bot to link a chat and enable messaging/deliveries. It does not explicitly mention exclusions or compare against list_channel_accounts, so it falls 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 declare this is a non-readonly, non-destructive, closed-world write. The description adds genuinely non-obvious behavior beyond that: agent-kind skills are inert with respect to run_skill, and defaultParams are merged at run time. It does not discuss persistence, name-slug collisions, or authorization, keeping it below the top score.

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

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

Two dense sentences, no filler, and the definition of a skill is front-loaded before the kind semantics. Every clause carries information an agent needs before calling.

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

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

With an output schema present, return values need no explanation, and the description covers the two conceptual unknowns (what a skill is, what kind determines). Minor gaps remain around name/slug generation behavior and whether creation is idempotent, but nothing essential to a correct call is missing.

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

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

Schema coverage is 67%, and the description compensates on the most ambiguous field by explaining what kind actually controls (the generated media type) rather than just listing the enum. It also reinforces the {{variable}} token convention in promptTemplate and the default-params merge semantics, though slug and description are left entirely to the schema.

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

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

States a specific verb and resource ('Create a reusable saved skill') and immediately defines what a skill is: a parameterized prompt template plus default params. This clearly separates it from list_skills, get_skill, update_skill, and run_skill without needing the schemas opened.

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?

Explains that kind selects the runnable output type and explicitly warns that agent skills are not runnable via run_skill, which is a real routing constraint between siblings. It stops short of contrasting create vs update_skill or stating prerequisites, so it is clear context rather than a full when/when-not matrix.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=false, so the safety profile is carried structurally. The word "Permanently" reinforces irreversibility but adds little beyond the annotation, and there is no disclosure of cascade behavior, failure modes for a missing id, or permission requirements.

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

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

One short sentence with zero filler, and the destructive qualifier is front-loaded right after the verb. Nothing is wasted, though the sentence is so terse that it leaves no room for the operational detail an agent would want.

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 and an output schema exists, so return values need no explanation, and annotations cover the safety contract. Still, for a destructive operation the description says nothing about what happens when the id does not exist or the skill is in active use, leaving a meaningful 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?

There is a single parameter with 100% schema description coverage — the schema already tells the agent it is 'The skill id from list_skills.' The phrase 'by id' in the description adds nothing new, so the baseline 3 for fully documented schemas applies.

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

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

States a specific verb (delete), resource (saved skill), and lookup key (id) in one sentence, so it is clearly distinct from siblings like update_skill, get_skill, and run_skill. It stops short of naming those siblings explicitly, which keeps it at 4 rather than 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?

The description never says when to reach for this versus update_skill or whether a non-destructive alternative exists. There is no mention of prerequisites, confirmation steps, or what to do if the skill is still referenced by a schedule — the agent must infer all of that.

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 non-read-only, non-destructive and closed-world, so the safety profile is covered. The description adds real context — generation is brand-grounded and falls back to a default saved brand — but says nothing about cost, latency, whether a job/asset is created, or what happens when 'wait' is false.

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 one-shot framing and the brand-grounding behavior; nothing is padded or repeated from the schema.

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

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

An output schema exists, so return values need not be described, and the brand-grounding plus default-brand fallback are the key behavioral facts. The remaining gap is sibling differentiation versus 'generate_image_ad' and any cost/async caveat.

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 29% (just 'prompt' and 'wait'), so the description must compensate. It does add genuine meaning for brandId/brandSlug by stating the default-brand fallback, but leaves 'count', 'model' and 'aspectRatio' completely unexplained in both schema and prose.

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 ('generates a static image ad') plus the distinguishing constraint that output is grounded in the saved brand's logo, colors, tone and products. It does not, however, explain how it differs from the sibling 'generate_image_ad', which an agent must disambiguate before choosing.

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

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

There is no when-to-use / when-not-to-use guidance and no mention of the near-identical sibling 'generate_image_ad'. The only routing-adjacent sentence ('Uses the default saved brand unless brandId/brandSlug is given') is a parameter default, not a usage rule.

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 'one-shot' framing signals it is a single end-to-end call, and the description discloses the brand-resolution dependency and its failure precondition. However, it says nothing about credit cost, job/async behavior when wait=false, or what happens if the saved brand lacks assets — meaningful gaps for a non-read-only generator. Annotations only cover the readOnly/destructive basics, so this is modest added value.

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

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

Three short sentences, front-loaded with the core action, then the brand-defaulting rule, then the prerequisite. No filler and nothing repeated from the schema or annotations.

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 critical brand prerequisite is covered, and an output schema exists so return values need not be explained. But for a seven-parameter, seven-value generation tool with 29% schema coverage, the missing guidance on duration units, valid platform values, aspect ratio defaults, and async behavior leaves real holes.

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 29%, so the description must compensate, and it does clarify the brandId/brandSlug semantics and default-brand fallback. But duration, platform, aspectRatio, and wait are left entirely to sparse or absent schema text, leaving five of seven parameters without meaningful explanation.

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: generates a UGC ad video grounded in the user's saved brand assets. The brand-grounding phrase implicitly separates it from generic siblings like generate_video and generate_ugc_video, but it never names those alternatives explicitly, so the differentiation is inferred rather than stated.

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

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

Gives concrete routing logic: use the default saved brand unless brandId/brandSlug is supplied, and call create_brand first if no brand exists. There is no explicit instruction about when to prefer this over generate_ugc_video or generate_video, so the alternative-selection guidance is incomplete.

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

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

Annotations already declare this is a non-readonly, closed-world, non-destructive write, so the bar is lower. The description still adds real operational context beyond them: the default is to block until completion, and the async path returns a job id consumed by get_job. It omits cost/rate-limit or latency expectations for a generation call.

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

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

Three sentences, each earning its place: what it produces, how to ground it, and how the async path works. The wait/get_job behavior is placed where the agent needs it without preamble.

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

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

With an output schema present and annotations covering the safety profile, the description covers the main decision points an agent needs: output count, grounding inputs, and the sync-vs-poll branch. The remaining gap is sibling disambiguation against generate_brand_image_ad and generate_video.

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 90%, so the schema already documents nearly every parameter; baseline is 3. The description adds genuine semantic value for referenceImageUrls (product, logo, prior creatives, grounding on brand identity), but brandId/brandSlug, aspectRatio, and model are left entirely to 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 verb+resource+quantity ('Generate 1-4 static image ads from a prompt'), so the core action is unambiguous. However, the sibling generate_brand_image_ad is not named or distinguished, even though this tool also optionally grounds output in a saved brand — an agent could reasonably confuse the two.

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 concrete selection cues: use referenceImageUrls to ground on brand identity, optionally attach a saved brand, and set wait=false when you want a job id to poll with get_job. It stops short of stating when NOT to use this versus generate_brand_image_ad or generate_video.

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 cover the safety profile (not read-only, not destructive, closed world), and the description adds genuinely new behavior: the tool renders burned-in captions and by default blocks until completion, with wait=false switching to a pollable job id. It does not mention render duration, cost, or failure modes, but the blocking/async disclosure is the key trait an agent needs.

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

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

Four compact sentences, front-loaded with the action and then the input rules and async behavior. Nothing is padded, though the preset sentence ('Choose a caption style with preset') adds little beyond the schema's enum.

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

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

All five parameters are documented at 100% coverage, the input branching and async/wait behavior are explained, and an output schema exists so return values need not be restated. 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 description coverage is 100%, so the baseline is 3; the description earns above that by explaining the relationship between parameters ('sourceJobId ... whose video + script are reused' vs. providing videoUrl and script together) that the flat schema cannot express.

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

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

Opens with a specific verb+resource ('Render burned-in captions onto a video') that is unmistakable and cannot be confused with the generate_video / generate_ugc_video siblings. It never explicitly routes against those siblings, but the operation itself is self-differentiating.

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

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

Gives an explicit mutual-exclusion rule for inputs ('either sourceJobId ... or both videoUrl and script') and a clear async branch (wait=false returns a job id to poll with get_job), naming the polling sibling. It stops short of saying when to prefer this over generating a fresh UGC job, so not 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 this is a non-read-only (generative) but non-destructive, closed-world operation, so the safety profile is covered. The description adds genuinely new behavior — that it blocks by default while waiting for the result — which matters for timeout handling. It does not disclose what is returned or what state exists when wait is false, or any credit/quota cost, so this is solid 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?

Three short sentences with no filler, and the most important information — what gets produced — leads. Slightly more could have been spent on the sibling routing rather than repeating the wait default already documented in the schema.

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

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

With 10 parameters (one required) and an output schema present, the return value does not need explaining, and the description covers the core pipeline adequately. What is missing is the practical consequence of wait=false and how this differs from the crowded set of sibling generation tools, which is the main thing an agent must decide before calling.

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 80%, so the baseline is 3. The description reinforces the roles of prompt ('from a brief'), brand grounding, and wait ('Defaults to waiting'), but it never disambiguates the three overlapping brand parameters (brandId, brandSlug, useDefaultBrand) or their precedence, which is the only real semantic gap left.

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 ('Generate') and a well-defined resource, and it decomposes the output into concrete parts (script + avatar + voiceover + captions), which tells the agent exactly what artifact it gets. It also notes the optional brand grounding. It stops short of naming which sibling to prefer over generate_video, generate_brand_video, or generate_subtitled_video, leaving overlap unresolved.

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

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

Usage is only implied: the output composition suggests this is the 'full ad' choice versus a bare video or a subtitled video, and 'Optionally ground it in a saved brand' hints at the brand-bound path. There is no explicit when-to-use, when-not-to-use, or named alternative despite four similarly named generation siblings in the toolset.

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?

Beyond the annotations (which only say this is non-read-only, non-destructive, non-open-world), the description discloses the blocking default (waits for result), the async escape hatch via wait=false and get_job, a billing caveat (Seedance models consume a separate allowance), mutual-exclusion constraints, and that lip-sync clip length is dictated by the audio. These are exactly the behavioral traits an agent cannot infer from structured fields.

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 mode enumeration is front-loaded and each clause carries information an agent needs (model families, parameter pairings, quota note, wait behavior). The sentences are long and densely packed, which makes the middle harder to scan than it needs to be given 17 parameters.

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 17-parameter, zero-required-parameter tool with strong output schema and 88% schema coverage, the description supplies the missing model-selection logic, the required-inputs handoff to list_video_models, and the per-mode parameter contracts. An agent can compose a valid call for each supported mode from this text alone.

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 already 88%, so the baseline is 3, but the description adds real cross-parameter semantics: first entry of imageUrls is the start frame with an optional end frame, audioUrl pairs with one image for OmniHuman/Kling Avatar or with sourceVideoUrl for Kling Lip Sync, and reference* arrays are model-gated and mutually exclusive with imageUrls. A few params (generateAudio, aspectRatio) are not addressed in the description, so it falls short of 5.

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 concrete verb+resource ("Generate a video with any model on the EzUGC dashboard") and enumerates the distinct generation modes it covers (text-to-video, image-to-video, references, lip-sync). It does not differentiate itself from sibling tools generate_ugc_video and generate_brand_video, even though its 'optionally ground it in a saved brand' capability clearly overlaps with the latter.

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 clear operating instructions: call list_video_models for model ids and requiredInputs, use wait=false plus get_job for async polling, and which parameter combination each mode requires. It also states an exclusion (frames and references cannot be combined). What is missing is routing guidance against the sibling video-generation tools that appear to do similar work.

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

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

Annotations already cover the safety profile (readOnly, non-destructive, closed-world), so the bar is lower. The description adds useful context about what the profile contains and how the asset URLs can be used, but it does not disclose operational details like error behavior for missing brands or any rate limits.

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

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

Two tight sentences, front-loaded with the tool's purpose followed by the field inventory and usage note. Every clause earns its place and nothing is redundant.

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

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

With an output schema, annotations, and full parameter documentation, the description is nearly complete for an agent to call it correctly. The only meaningful gap is the lack of clarification about how this differs from get_brand_assets, which returns overlapping asset URLs.

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 brandId parameter is fully documented in the schema as coming from list_brands / create_brand. The description adds no additional meaning beyond that baseline, so a 3 is appropriate.

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

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

The description states a specific verb and resource—getting a saved brand's status and extracted profile—and enumerates the returned fields (brandMd, tone of voice, value props, colorPalette, logo/product URLs). This is much clearer than a generic 'get brand', though it does not explicitly differentiate itself from sibling tools like list_brands or get_brand_assets, which could overlap on asset URLs.

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

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

The sentence 'Use these asset URLs as reference images for on-brand generation' gives a clear downstream use for the output, but it does not explain when to choose this tool over list_brands or get_brand_assets. Tool-selection guidance 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?

The description adds a critical operational detail: that the assets are provided 'each with a temporary signed URL.' This is a functional behavior crucial for any downstream call that relies on the asset, which is not captured in the static 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 highly efficient, combining the resource type, the scope of assets included, and the mechanism of delivery into a single, powerful statement without unnecessary 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?

It is highly complete for a resource listing tool. It explains exactly what the agent will receive and how that data should be utilized, fulfilling the role of a discovery tool perfectly.

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

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

Since the schema description coverage is low (33%), the description compensates by defining what kind of assets are listed (uploaded vs. generated) and the purpose of the output (used for generation). This helps the agent understand the semantic nature of the identifiers.

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 tool clearly states it lists brand assets, distinguishing between 'uploaded brand assets' and 'previously generated brand creatives.' This makes its purpose specific and clearly differentiated from other brand retrieval tools in the sibling list.

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 excellent downstream usage guidelines by explicitly instructing the agent to 'Use those URLs as referenceImageUrls (image) or imageUrls (video)' for generation tasks. This defines the practical context in which the tool should be invoked.

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 destructiveHint=false, so safety is covered; the description adds the important behavioral fact that this is a polling endpoint for async jobs started with wait=false, which is not derivable from annotations. It doesn't discuss behavior for pending/failed jobs, but the output schema carries the return shape.

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: the first front-loads what is returned, the second front-loads the usage condition. No filler, no repetition of the title.

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

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

With an output schema covering return values, annotations covering the safety profile, and the sole parameter fully documented, the description only needed to supply the async/polling context — and it does. Nothing required to invoke it correctly is missing.

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

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

There is a single parameter at 100% schema coverage, and the schema already explains that jobId is the id returned by a generate_* tool. The description's "by id" adds no format or sourcing detail beyond that, so this is baseline territory with the schema doing the work.

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

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

States a specific verb and resource (get a job) plus exactly what is returned — status and the resulting video/image URL — and names the job type space (video/UGC/image). An agent can distinguish it from list_jobs and the generate_* siblings without opening any schema.

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

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

"Use this to poll jobs created with wait=false" gives a concrete triggering condition tied to a sibling behavior, which is the key usage signal. It stops short of explicitly naming list_jobs as the alternative for enumerating jobs, so it falls just under 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=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered without the description. The description itself adds nothing beyond the title: no note on what a missing/invalid id yields or what the payload contains.

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

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

One short, front-loaded sentence with no filler. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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

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

An output schema exists, so return values need no explanation, and the single-parameter surface is simple. Still, nothing is said about behavior for an unknown id or how this relates to run_skill/list_skills, leaving a modest gap.

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

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

Schema coverage is 100% with a single required skillId, and the schema description already explains it comes from list_skills/create_skill. The description adds no further meaning, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ("Get a single saved skill by id") and the word "single" implicitly contrasts with list_skills. It is clear enough to select over the list/create/update siblings, though it does not name them explicitly.

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

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

There is no statement of when to use this instead of list_skills or run_skill, and no prerequisites or failure conditions. The only routing hint ("id from list_skills / create_skill") lives in the schema, not the 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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds the concrete contents of the response (usage, limit, remaining, subscription status), which is modest added context. It says nothing about freshness, caching, or account scoping, so it stays at an adequate level.

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

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

A single front-loaded sentence with no filler. Every clause enumerates a returned field, so nothing is wasted.

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

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

For a zero-parameter, read-only tool with a full output schema and explicit annotations, the description supplies everything needed to invoke it. Only minor gaps remain, such as whether the quota is per-account or per-period.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. Schema coverage is 100% and the empty input object is unambiguous.

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 ("Return") and names the exact resource fields it reports: usage, limit, remaining quota, and subscription status. An agent can tell what it gets without opening the output schema. It does not explicitly contrast with siblings, but none of the listed siblings overlap in purpose.

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

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

There is no explicit statement of when to call this tool versus alternatives, nor any preconditions. The use case (checking quota before generating videos) is only inferable from the field list, not 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, destructiveHint=false and openWorldHint=false, so safety is covered. The description contributes that results include cadence, next fire time, and last run, but says nothing about ordering, result limits, or whether disabled schedules appear by default (that detail lives only in 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?

One sentence, front-loaded with the verb and resource, with the parenthetical and returned-field list each earning their place. No filler or restatement of the title.

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

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

With an output schema present, the description need not explain return values, and annotations cover the safety profile; the one optional parameter is fully specified in the schema. The only minor gap is the absence of any hint about result volume or ordering, which matters little for a per-account schedule list.

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

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

Schema description coverage is 100% and the single optional parameter includeDisabled is fully documented in the schema with its default. The description adds no further meaning about that flag, 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?

Specific verb (List) plus specific resource (Super Agent schedules) with a clarifying parenthetical defining what a schedule is (recurring/one-off autonomous triggers), which separates it from sibling concepts like skills and jobs. It also previews the returned fields (cadence, next fire time, last run), so an agent knows exactly what this call yields before opening the schema.

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

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

The listing nature implies the use case (enumerate schedules before pausing or inspecting one), but the description never states when to use this versus alternatives such as get_job or the related create/pause schedule tools. There are no exclusions or prerequisites stated; usage must be inferred from the verb.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered by structured data and the description's 'read-only' wording adds nothing new. It does disclose the catalog contents (name, description, parameters), which is mild added context, but says nothing about size, pagination, or freshness of the catalog.

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 names the action, the scope, and the payload in that order. There is no filler and nothing to trim.

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

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

A zero-parameter, read-only list tool with an output schema and full annotation coverage needs little prose, and the description covers purpose and payload. The only meaningful omission is disambiguation from `list_skills`, which is the one thing an agent could still get wrong.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline is 4. The description correctly signals the call is argument-free by describing a full-catalog listing rather than a filtered query.

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

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

States a specific verb ('List') and a precisely scoped resource ('read-only catalog of agent tool capabilities ... the conversational agent can use'), plus the returned fields. It is clear what the tool does, but it never explicitly distinguishes itself from the nearby sibling `list_skills`, which an agent could easily mistake for the same thing.

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 it applies (introspecting what the agent itself can do) but gives no explicit trigger, no exclusions, and never names `list_skills` as the alternative to use instead. An agent has to infer the routing decision from the resource wording 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, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered without the description. The description adds the shape of the result set (workspace fields) but says nothing about ordering, pagination, or empty-result behavior — though with zero parameters there is no filtering story to tell.

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

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

A single front-loaded sentence with the resource stated first and the payload fields parenthetical. Not a word is wasted.

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

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

With no parameters, three annotations, and an output schema present, the definition covers what an agent needs to call it. Minor gaps: whether all brands are returned at once and in what order are unstated, but the output schema covers the return shape.

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

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

The tool takes zero parameters, so the baseline of 4 applies; nothing needs to be explained beyond the schema. The field list in the description actually describes outputs rather than inputs, so it does not compensate for any parameter gap because none exists.

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

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

States a specific verb ("List") and resource ("the user's saved brand workspaces"). It also enumerates the returned fields (id, slug, website, status, name, logos). It is clearly distinct from create_brand/get_brand by the plural list framing, but it never names a sibling explicitly.

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

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

There is no when-to-use guidance, no exclusion, and no pointer to alternatives such as get_brand for a single brand. The only signal is the implicit plural in "List", leaving the agent to infer that this is the discovery call before a get_brand.

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, destructiveHint=false, openWorldHint=false, so safety is covered. The description adds useful scoping ('linked to this EzUGC account') and tells the agent what kind of entities come back, but says nothing about empty results, result shape, or what happens if nothing is linked.

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

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

A single front-loaded sentence with the resource named first and the qualifier trailing. No wasted clauses, though the '24/7 agent messaging' tail is context rather than operational information.

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

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

With an output schema present, the description needn't explain return values, and annotations cover the safety profile. For a one-optional-param read tool this is close to complete; only the tie-in to the linking flow (create_channel_link_token) is missing.

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

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

The only parameter (channel) has 100% schema description coverage ('Filter by channel, e.g. \'telegram\'.'), so the schema carries the semantics. The description reinforces the channel concept via the Telegram example but adds no extra detail such as case sensitivity or valid values beyond the schema.

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

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

States a specific verb+resource ('List external messaging accounts ... linked to this EzUGC account') and clarifies what those accounts are with a concrete example (Telegram chats). It is clearly distinct from the write-side sibling create_channel_link_token, though it never names siblings 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?

There is no explicit when-to-use guidance and no reference to alternatives such as create_channel_link_token (to link a new account) or whoami. The '24/7 agent messaging' phrase hints at context but leaves the agent to infer the workflow on its own.

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, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description's added behavioral value is limited to naming the returned attributes, which the output schema already carries, and it says nothing about ordering, pagination or whether the list is brand-scoped. Some value added, but not much beyond structured fields.

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

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

Two sentences, both earning their place: the first defines the payload, the second defines the call sequence. The return content is front-loaded before the usage instruction, which is the right order for a discovery tool.

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

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

With no parameters, full annotation coverage and an output schema describing the return shape, the description supplies everything else an agent needs: what the list contains and where it sits in the workflow. Nothing material is missing for a zero-arg discovery endpoint.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. It does not misrepresent any input, and correctly implies the call is unfiltered.

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?

Uses a specific verb ('List') with a precisely scoped resource ('every available static image-ad model'), and even enumerates what attributes come back (reference-image support, aspect ratios). The word 'static image-ad' implicitly separates it from the sibling list_video_models, so an agent can pick the right lister without opening either schema.

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

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

Explicitly states the trigger and the downstream step: 'Call this to retrieve available model ids before calling generate_image_ad.' That gives a clear sequencing rule rather than leaving the agent to infer it. It stops short of naming when-not-to-use or pointing at list_video_models as the alternative, so it is a strong 4 rather than 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=true and destructiveHint=false, so safety is covered; the description adds genuinely new behavioral facts: account-wide scope, most-recent-first ordering, and that results include status and result URLs. It doesn't say whether history is truncated at 50 or how to reach older jobs, which for a "recent history" tool is a real omission.

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 resource scope before the usage hint and the parameter note. The final sentence largely duplicates the schema's own parameter description, which is the only wasted space.

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

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

With an output schema present, return values needn't be explained, and annotations plus full schema coverage handle safety and the one parameter. The remaining gap is whether the list is bounded to a recent window and whether older jobs are retrievable, which matters for the stated "resume past work" use case.

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

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

Schema description coverage is 100% and the single limit parameter is fully documented there, including the 1-50 range and default 20. The description restates that verbatim rather than adding semantics (e.g. ordering interaction or behavior at the cap), so baseline 3 applies.

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

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

States a specific verb and resource ("Browse the account's recent generation history") and enumerates the job types returned (video, UGC, image-ad, subtitle) plus what each carries. An agent can distinguish it from generate_* siblings, though it never names get_job, the natural counterpart for a single 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?

"Use this to review or resume past work" gives a clear positive use case, and the default/limit bounds are stated. It stops short of explicitly routing the agent to get_job for a single job or list_brands for other listing needs, so no true when-not guidance exists.

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful domain context — that skills are parameterized prompt templates that dispatch video/ugc/image jobs — which helps an agent judge relevance. It does not mention result volume, pagination, or ordering, but with an output schema present the return shape is documented elsewhere.

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

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

A single sentence with the action front-loaded and a compact clarifying gloss attached. Every clause earns its place; there is no filler or repetition of the title.

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

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

For a no-parameter, read-only listing tool with an output schema and full annotation coverage, the description supplies enough to call it correctly. The one real gap is the unresolved overlap with the near-named sibling 'list_agent_skills', which is exactly the ambiguity a description should resolve.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The scope word 'account's' is the only semantic constraint and it is stated.

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

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

States a specific verb and resource ('List the account's saved skills') and adds a parenthetical definition of what a skill is (reusable parameterized prompt templates that dispatch video/ugc/image jobs). That is clear on its own, but it does nothing to distinguish it from the sibling 'list_agent_skills', which an agent could easily confuse it with.

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

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

There is no statement of when to use this tool, when not to, or which sibling to prefer. With 'get_skill', 'run_skill', 'list_agent_skills', and 'create_skill' all present, the description gives no routing guidance and leaves the agent to infer that this is the enumeration step before run_skill.

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

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

Annotations already declare this as a read-only, non-destructive, closed-world operation, so the safety profile is covered. The description adds useful context about what information is returned, but does not disclose behavioral details like pagination, ordering, rate limits, or authentication requirements.

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

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

The description is two tight sentences with zero waste. The primary purpose is front-loaded, followed immediately by the invocation guidance.

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 listing tool with annotations covering safety and an output schema covering return values, the description is complete enough. It states what the tool returns and when to call it, leaving no critical gap for an agent.

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

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

The tool takes zero parameters, so parameter semantics are inherently minimal. With no inputs to explain, the baseline score is 4 and the description does not need to compensate for schema gaps.

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 every available video generation model. It also enumerates the data returned (capabilities, durations, API availability) and distinguishes itself from the generate_video sibling by positioning itself as the prerequisite lookup step.

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 clear usage context: call this to retrieve available model ids before calling generate_video. It does not explicitly state when not to use it or name alternatives such as list_image_models, so it falls short of full when/when-not 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 declare a non-destructive mutation; the description earns credit by adding the actual effect ('stops future autonomous runs') and the state outcome ('without deleting the schedule', implying reversibility via resume). It stops short of saying whether an in-flight run is cancelled or what happens on an invalid/unknown id.

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

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

Two short sentences, zero filler, with the default mode and the non-destructive guarantee front-loaded ahead of the incidental detail.

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

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

An output schema exists and annotations cover the safety profile, so return values need not be explained. For a two-param toggle the description is nearly complete, missing only edge-case behavior such as unknown ids or the fate of already-running invocations.

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 'enabled' already documents 'true to resume, false/omit to pause', so the description's parenthetical '(default)' is essentially redundant with the schema. Baseline 3 applies; no new syntax or format meaning is added.

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 pair (pause/resume) and a specific resource (Super Agent schedule) scoped by id. This is trivially separable from the sibling create_agent_schedule and list_agent_schedules, and the default behavior (pause) is stated up front.

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

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

Usage is only implied: the phrase 'without deleting the schedule' suggests pausing is the softer alternative to deletion, but no sibling or alternative is named explicitly and no precondition (e.g. schedule must exist, must be yours) is given. An agent can infer when to use it, but the description doesn't route it.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=false; the description adds that it dispatches a generation job and that it blocks waiting for the result by default, which is meaningful for latency-sensitive callers. It does not mention cost/credit consumption or what happens on template/variable mismatch, which keeps it below a 5.

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

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

A single front-loaded sentence with the core action first and the mechanics after, plus one short sentence on the default wait behavior. No filler.

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

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

With full schema coverage, an output schema, and annotations, the description covers what an agent needs to invoke correctly. The minor gap is that it does not state the cost/credit implications of dispatching a generation job or the error surface for missing variables.

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

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

Schema coverage is 100%, so the schema already documents skillId, variables, overrides, and wait. The description restates the same semantics (variables -> template tokens, overrides -> merged over defaults) rather than adding format or validation detail, so the baseline 3 applies.

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

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

States a specific verb and resource ("Run a saved skill") and then enumerates the three concrete operations it performs: rendering the prompt template with variables, merging overrides over defaults, and dispatching a generation job. This is clearly distinguishable from siblings like create_skill, update_skill, delete_skill, and get_skill.

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

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

Usage is only implied: the description conveys that this is the execution step for a saved skill, but never says when to prefer it (e.g., after create_skill or get_skill), nor mentions prerequisites such as obtaining skillId from list_skills. No exclusions or alternatives are named.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, so the risk profile is known from structured data. The description adds two genuinely useful traits — brand resolution precedence and 'Editing brandMd bumps its version' — but it never warns that the supplied Markdown wholesale overwrites the existing brand book, which is the actual destructive behavior an agent should be told about.

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

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

Two dense sentences, front-loaded with the primary action and followed by resolution and side-effect details. No filler, no repetition of the title.

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

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

An output schema exists, so return values need no explanation, and the description covers scope, target resolution, and the version-bump side effect. It stops short of the overwrite semantics and any readiness/precondition constraint on the default brand, which would make a mutation tool fully self-describing.

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

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

Schema description coverage is 100%, including the crucial 'replaces the existing brandMd' note, so the schema does the heavy lifting. The description only restates the id/slug/default resolution order and the optionality of toneOfVoice, adding little 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?

States a specific verb (update) and resource (a saved brand's brandMd Markdown), and explains what brandMd is ('the brand DNA used to ground on-brand generations'), which unambiguously separates it from create_brand, get_brand, and update_skill. The secondary scope (optional tone of voice) is also called out.

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

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

Implies when to use it (you have a saved brand and new brand book content) and how the brand is targeted ('id, slug, or the default saved brand'), but never says when NOT to use it or points to an alternative — e.g. fetch with get_brand first, or use create_brand for a new brand. Guidance is inferred 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 destructiveHint=true and readOnlyHint=false, so the risk profile is known; the description usefully adds patch semantics rather than full replacement. It does not disclose that replacing promptTemplate or defaultParams overwrites prior content irreversibly or what happens when skillId is unknown — the main residual gaps behind the destructive hint.

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, zero filler, with the mutation semantics front-loaded ahead of the use case. Every sentence adds 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 destructive partial-update tool with a nested defaultParams object and an output schema, the description covers the essentials: what changes, what is preserved, and the typical use. Missing only edge-case behavior (invalid skillId, overwrite consequences) and the undocumented scalar fields.

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

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

Schema coverage is only 50%, and the description only mentions promptTemplate and defaultParams — two of the parameters the schema already documents. The undocumented name, slug and description parameters, and any uniqueness constraints on slug, are left unexplained, so it does not compensate for the coverage gap.

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 ("Update a saved skill in place") and even names the affected surfaces (prompt template, default params). It is clearly distinguishable from create_skill, delete_skill, run_skill and get_skill by name and wording, though it never explicitly routes away from those 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?

"Only the provided fields change; omit a field to leave it unchanged" gives the agent a clear partial-update contract, and "Useful for tweaking a prompt template or its default params" names the common case. No exclusions or alternatives are given (e.g. when to use create_skill or delete_skill instead).

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

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

Annotations already establish this as a safe, closed-world read. The description adds value beyond them: it discloses that the call actually validates the configured key and enumerates what the response reports, which is exactly the pre-flight context an agent needs.

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 the return payload, then the usage directive. Nothing is padded or repeated from the title.

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

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

With an output schema covering return values, zero parameters, and descriptive annotations, the description supplies everything else an agent needs: what gets checked and that it should run before other work. No meaningful gap remains.

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

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

The tool takes zero parameters, so the baseline of 4 applies and there is nothing schema-side left to clarify. The description correctly implies the key comes from configuration rather than an argument.

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 (verify the configured EzUGC API key) plus exactly what is returned (account, scopes, subscription status). No sibling tool does credential verification, so it is unambiguous against the rest of the list.

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

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

"Call this first" gives explicit ordering guidance that an agent can act on immediately. It does not name an alternative or exclusion case (e.g., when not to bother re-verifying), so it stops just short of full when/when-not coverage.

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