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

Annotations only state the safety profile (readOnly/destructive/idempotent hints), whereas the description adds genuinely non-derivable behavior: an in-flight cloud request may still complete and be charged, and its response is cached for later resume. That cost/irreversibility context is exactly what an agent needs and is not in the 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 tight sentences, with the scope/action front-loaded and the cost caveat second. Every clause carries information; there is no padding 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?

The output schema is present so return values need not be described, and the description covers the key caveats (partial cancellation, billing, resume caching). The remaining gap is the undocumented job_id and idempotency expectation, minor against an otherwise complete cancel 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?

There is one required parameter (job_id) with 0% schema description coverage, so the description carries the full burden, yet it never explains what job_id is or where to obtain it. The name is fairly self-evident, but the description adds no meaning beyond the schema.

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

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

The verb 'Stop' plus the resource ('owned local rendering and pending files') makes the cancel intent clear, and the mention of an in-flight cloud request distinguishes behavior from a plain list/get job tool. It never uses the word 'cancel' or the job_id, so the mapping to the tool name is inferred rather than stated, keeping it just under 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: stopping work that is 'owned' and cannot be fully recalled on the cloud side. The cache-for-resume note hints that resume_job is the follow-up path, but no explicit when-to-use or when-not-to-use condition is given, and siblings like resume_job/get_job are not 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?

Adds substantial behavior beyond the annotations: the call is asynchronous and returns a job ID, audio is transmitted off-machine for API recognition, AI edits send text, MP4 rendering stays local, and the original video is preserved. The privacy/processing split and the non-destructive guarantee are exactly the context an agent needs before invoking.

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

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

Four short, dense sentences with the core action and polling contract front-loaded; nothing is padding. Slightly telegraphic phrasing ("API recognition sends audio") costs a little readability but wastes no space.

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

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

An output schema exists, so return values need no explanation, and the async flow plus preservation guarantee cover the biggest risks. For a 16-parameter tool, though, the silence on rendering/style/translation options and on overwrite versus preserve behavior leaves real 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 0% across 16 parameters, so the description must carry the load, and it explains only two: captions_path's bypass behavior and the implicit engine split (api vs local). The remaining 14 parameters (burn, size, length, correct, glossary, language, position, style_id, overrides, overwrite, safe_area, translate_to, input_path, output_dir) get no semantics at all.

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 ("Start captioning one local video or a folder") and immediately clarifies the async contract ("Returns a job ID immediately; poll get_job"). No sibling tool does captioning, and it names get_job as the poll target, so an agent can place it precisely in the workflow.

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 operational context: start the job here, then poll get_job; and states the alternate entry path ("captions_path reuses an existing SRT/VTT/JSON without recognition") that skips recognition. It does not state when not to use it or contrast engine choices as a decision rule, so it falls short of explicit alternatives.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so safety is covered; the description adds a genuinely useful, non-obvious security disclosure: 'Never returns the key.' That is exactly the kind of extra context annotations cannot express, though it says nothing about non-key output or error behavior.

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

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

Two short sentences with no filler: what is checked is front-loaded, and the security caveat follows. Every clause earns its place.

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

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

An output schema exists, so return values need not be explained, and the description covers the inspected surface plus a security note. The main gap is the absence of usage context, which is already penalized under usage guidelines; otherwise the definition is sufficient to invoke 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?

Zero parameters, so per the rubric the baseline is 4. The description adds nothing parameter-related because there is nothing to describe.

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 ('check') and enumerates exactly what is inspected: media tools, fonts, API-key availability, and offline recognition. It is a clear diagnostic purpose, though it does not explicitly differentiate itself from the font/style-listing siblings like list_fonts and list_styles, which superficially overlap.

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

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

There is no statement of when to call this versus alternatives, nor any prerequisite or workflow context (e.g., 'run before caption_video to verify required binaries'). The agent must infer the diagnostic use case entirely from the content list.

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 readOnly/idempotent/non-destructive, but the description adds non-obvious facts beyond them: that audio is measured locally and that no credit is reserved. The 'does not reserve credit' detail is exactly the kind of side-effect clarification an agent needs and is not derivable from the annotations.

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

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

Three tight sentences; purpose is front-loaded, followed by the parameter behavior and the no-reservation guarantee. No filler and nothing repeated from 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?

With an output schema present and annotations covering the safety profile, the description only needs purpose, the one non-obvious parameter, and side effects — all of which it provides. Marginally incomplete in that it never frames this against the actual-usage tool get_usage.

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 carries the burden, and it explains text_chars meaningfully: it only contributes to the estimate when supplied, otherwise that cost is excluded. input_path is left unexplained, but its meaning is self-evident, so coverage is adequate.

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 ('Estimate cloud cost before transcription'), which is distinct from every sibling (get_usage reports actual usage, caption_video does work). It stops short of naming the tool it contrasts with, so it is clear but not fully sibling-differentiated.

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 conditional instruction for supplying text_chars ('supply known text_chars for editing/translation, otherwise their cost is excluded'), which is genuinely useful usage context. However, it never says when to call this estimator at all versus alternatives like get_usage or preview_style, so 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful content context ('verified outputs and per-file failures'), but says nothing about error behavior when the job_id is unknown or what state a job must be in to be readable.

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

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

A single front-loaded sentence with the verb and resource first and no filler. Every clause earns its place by adding return-content 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, so return values need not be enumerated in the description, and the annotations carry the safety profile. For a one-parameter read tool this is nearly complete; the only shortfall is the unexplained job_id, which the description leaves entirely to the schema.

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

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

Schema description coverage is 0% and the sole parameter job_id carries no description. The description does not explain where the job_id comes from or its format, so it fails to compensate for the schema gap on the one parameter that matters.

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

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

States a specific verb ('Read') and resource ('saved caption job'), and adds scope detail (verified outputs, per-file failures) that separates it from list_jobs, cancel_job, and resume_job. It does not explicitly name a sibling, but the single-job read framing is unambiguous.

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

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

The phrase 'a saved caption job' implies fetching a specific existing job (e.g., after caption_video) rather than enumerating them, which implicitly distinguishes it from list_jobs. However, it gives no explicit when-to-use condition, no prerequisite for obtaining the job_id, and no stated exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is fully covered. The description adds one genuinely useful behavioral fact outside the annotations — the API-key prerequisite — but says nothing about rate limits, freshness of the usage data, or billing-period semantics.

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, no filler, with the core purpose front-loaded and the requirement trailing as a qualifier.

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

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

An output schema exists, so return values need not be described, and annotations carry the safety profile. Combined with the auth prerequisite, the definition is nearly sufficient, missing only a note on how current the monthly estimate is or when it fails.

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 is 4; there is nothing for the description to disambiguate and the schema is trivially 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?

States a specific verb and resource: reading cloud API usage plus estimated monthly charges. No sibling (list_jobs, estimate_video, check_environment, etc.) overlaps with usage/billing reporting, so the tool is easily told apart, though the description never explicitly contrasts itself with them.

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

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

The description gives a precondition ('Requires a locally configured API key') but no when-to-use guidance, no alternatives, and no indication of what to do if the key is absent. Usage is implied rather than stated.

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

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

Annotations already cover the safe-read profile (readOnlyHint, idempotentHint, destructiveHint false), so the bar is low. The description adds useful context beyond them: fonts are bundled and intended for local rendering, and the IDs are meant to be consumed by other tools. It doesn't note any availability constraints, which is the only gap.

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

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

Two sentences with zero filler; the resource and its payload are front-loaded and the follow-up action is second. Every sentence earns its place.

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

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

With an output schema present, return values needn't be spelled out, and with no input parameters there is nothing else to document. The description supplies the remaining needed context: what the IDs are for and where to use them next.

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 per the baseline a 4 applies. The description's only parameter-like content refers to other tools' overrides argument, not its own, which is appropriate rather than redundant.

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 (bundled named fonts) and enumerates the returned attributes (IDs, licenses, script coverage), which distinguishes it from the sibling list_styles. An agent can tell at a glance this is the font-inventory tool.

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

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

It gives an explicit downstream usage path: feed a font_id as overrides to preview_style or caption_video. It does not state when not to use it or name a conflicting alternative, but for a zero-param discovery tool the routing guidance is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds useful durability context (jobs surviving/interrupted by a restart), but says nothing about pagination, result caps, or the default limit despite there being an output schema it could complement.

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 tight sentence, front-loaded with the primary context. Nothing is wasted, though the phrasing is slightly indirect for a list operation.

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 one-optional-param list tool with an output schema (so return values need not be explained), the description covers the trigger scenario adequately. It still omits the meaning of the limit parameter and any paging behavior, leaving a small but real 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 0% and the single 'limit' parameter is undocumented in both schema and description. With low coverage the description is expected to compensate, but it makes no mention of result count or paging behavior at all.

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 the resource (durable jobs) and a use scenario, but the verb 'Find' is softer than the tool's actual list semantics and it never states that it returns a collection of jobs. It does not explicitly distinguish itself from the sibling get_job, so an agent must infer the list-vs-single distinction from the name alone.

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

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

It gives a genuine trigger context ('after reconnecting', jobs interrupted by a restart), which is more than most tools offer. However, it never states when not to use it or points to get_job for retrieving a specific job, leaving the alternative-selection decision 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=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context — a fixed count of 15, 'portable', and 'conservative platform safe areas' — but says nothing about ordering, stability, or whether the set is platform-dependent.

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 dense sentence with no filler or repetition. It is slightly overloaded (four distinct concepts packed into one clause), but everything stated is informative and front-loaded.

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

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

An output schema exists, so return-value explanation is unnecessary, and the zero-parameter surface keeps complexity low. However, for a discovery tool that agents will call to decide what to render, the absence of any usage/routing guidance leaves a real 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 tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate, and it correctly implies a no-argument call.

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 ('Return') and enumerates what comes back: portable presets, supported overrides, aliases and platform safe areas. An agent can tell this is an enumeration/listing tool rather than a mutating one, though the domain term 'styles' itself is never defined and no sibling (e.g. preview_style) is contrasted.

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 at all. With siblings like preview_style, check_environment and list_fonts present, the description never says when to call list_styles versus those alternatives, nor any prerequisite.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the cost-side-effect fact ('does not call a paid API') and the output nature (caption PNG on a neutral backdrop), which is useful context, but omits output format details or any constraints.

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 core action and followed by the key distinguishing trait. No filler; every clause carries information.

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

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

For a tool with 8 undocumented parameters, no output schema, and zero schema description coverage, the description is too thin to call it correctly. It doesn't explain what the parameters control or what the returned PNG will depict beyond 'caption on neutral backdrop'.

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% across 8 parameters, and the description mentions none of them. Opaque parameters like 'overrides', 'style_id', 'safe_area', and 'position' are left completely undefined, so the description does not compensate for the coverage gap at all.

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: 'Return a caption PNG preview with a neutral backdrop.' An agent can tell it produces an image preview rather than a video render (caption_video) or a style listing (list_styles). It does not, however, explicitly name or differentiate itself from siblings like estimate_video or run_demo.

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?

'Does not call a paid API' implies this is a cheap, safe way to preview before invoking a paid render, which is a usable when-to-use signal. But it never states explicit conditions or names an alternative tool, leaving the routing inference to the agent.

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

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

Annotations already declare this as a non-read-only, non-idempotent, non-destructive write. The description goes further by disclosing the partial re-execution model: completed files are skipped, only failed files are retried, and successful cloud responses are reused. That is real behavioral value beyond the structured hints, though it says nothing about permissions, cost, or what happens if the job is already complete.

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 stating the action, the eligible job states, and the resume semantics, with no filler or repetition.

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

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

An output schema exists, so return values need not be explained, and the description covers the core resume semantics well for a one-parameter mutation tool. It is slightly incomplete on preconditions and on behavior when the target job is already finished.

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% for the single required parameter job_id, so the description technically fails to compensate. The parameter is self-evident from its name and the resource, so no format or sourcing detail (e.g., where to obtain the id) leaves an agent materially blocked, but the baseline remains 3.

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

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

The description gives a specific verb ("Resume") and resource ("job") and narrows the applicable job states to interrupted/cancelled/failed, which lets an agent separate it from get_job, list_jobs, and cancel_job. It never explicitly contrasts itself with those siblings, 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?

Usage is implied by the state qualifier (resume only a job that is interrupted, cancelled, or failed), which is genuinely useful context. However, there is no explicit guidance on prerequisites (e.g., must the job still exist or be in a resumable state) and no named alternative such as get_job for checking status first.

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 mark it non-read-only, non-idempotent and non-destructive, so the safety profile is partly covered. The description adds genuinely useful behavioral context not in the annotations - that no API key is needed and credits are bundled (cost implications). It does not disclose where the file lands or what happens on repeated runs.

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, front-loaded sentences with no filler - the core action leads and the setup/cost caveats follow. Appropriately sized for a simple demo 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?

An output schema exists, so return values need not be explained, and the tool's purpose and prerequisites are clear. Still, the two parameters - notably style_id's semantics and output_dir's role - remain unexplained, which is a real gap for a tool that writes a file somewhere.

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%: neither style_id (with default 'word-highlight') nor the required output_dir is documented anywhere, and the description never mentions them. It therefore fails to compensate for the schema gap, leaving both parameters opaque.

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 (Export) and resource (bundled 6-second human-narration sample with animated captions), and the 'bundled sample / no upload' framing implicitly distinguishes it from caption_video, which processes user footage. It does not explicitly name that sibling, so differentiation is inferred rather than stated.

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

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

The 'no API key, upload or model download required' and 'credits bundled' lines imply a zero-setup trial/evaluation use case, which is useful context. However, there is no explicit statement of when to prefer this over caption_video or when it is inappropriate, leaving routing to inference.

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