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

With no annotations, the description carries the full burden, and it does disclose two real traits: the layer affects every track below it (a side-effect not in the schema) and dry-run is the default behavior. It still omits how a write behaves, whether the layer is removable/reversible, and what the dry-run output contains, leaving notable behavioral gaps for a mutation tool.

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 carries purpose, options, impact scope, and the dry-run default with essentially no filler. The parentheticals are dense but each earns its place; the only minor cost is that the trailing default note is somewhat buried.

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

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

For a 7-parameter, nested-object, no-output-schema mutation tool with no annotations, the description covers purpose, scope of effect, and defaults but leaves the 'track' parameter, the adjust object's structure, and the dry-run/commit result semantics unexplained. Adequate to attempt a call, but not complete enough to predict outcomes.

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 43%, so the description must compensate, and it partially does: it explains lut, the time-range parameters implicitly, and delegates 'adjust' semantics to capcut_set_clip's key/UI-value convention, which is genuinely useful. It says nothing about the 'track' parameter or the format/units of start_s and duration_s, so the undocumented half of the schema remains unexplained.

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 (add an adjustment layer, CapCut 'Ajustar') and pins down scope (over a time range) plus optional decorations (basic adjust, LUT). It also names the exact behavioral distinction from sibling operations by noting it 'affects every track below it,' and cross-references capcut_set_clip for key semantics, so an agent can separate it from capcut_add_filter or capcut_add_effect.

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

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

The description conveys that the tool is a range-spanning, track-below grade and that it dry-runs by default, which implies it is for global looks over an interval rather than a single clip. However, it never explicitly states when to prefer this over capcut_add_filter, capcut_add_effect, or per-clip capcut_set_clip, nor does it state the precondition for committing changes beyond what the parameter schema says.

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

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

No annotations exist, so the description carries the full burden. It discloses the default dry-run plan mode and notes the segment/resource targeting, but does not cover permissions, reversibility, ordering, or what a write actually mutates. The 'CapCut must be closed' constraint lives only in the schema, not the description.

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

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

Front-loaded with the verb and resource, followed by the target and dry-run note. Two sentences cover a lot without filler; the parenthetical examples are dense but earn their space as lookup aids.

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

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

Adequate for the core call, but with 8 parameters at 50% schema coverage, no annotations, and no output schema, several parameters (track, name, and the duration_s semantics) rely entirely on the schema. The description is serviceable but leaves the agent relying on structured fields for a mutation 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?

Adds genuine meaning beyond the schema: it maps kind values to element types (text/sticker for loop, combo for group) and gives concrete resource_id examples tying numeric IDs to animation names. With only 50% schema coverage this partially compensates, though name, track, and duration_s get no description-level 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 ('Add an in / out / loop / group animation'), the target ('segment at start_s by resource_id'), and the key operating mode ('Dry-run by default'). An agent can distinguish it from capcut_add_effect or capcut_add_transition by the animation construct alone, though no sibling is named.

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

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

The 'Dry-run by default' note hints at the intended safe workflow, and the kind parentheticals (text, sticker, combo) imply which animation type applies to which element. But there is no explicit when-to-use, no when-not, and no mention of alternatives among the many add_* siblings.

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

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

With no annotations, the description carries the full burden. It does disclose two key behavioral traits: the dry-run default (so nothing is written unless overridden) and the default 'music' track. It omits the requirement that CapCut be closed and says nothing about permissions or reversibility, so it is helpful but incomplete for a write-capable tool.

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 clauses, front-loaded with the action and followed by capability and default notes. No wasted words, though it is a bit terse for an 11-parameter 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?

For an 11-parameter, unannotated tool with no output schema, the description is only minimally sufficient. It covers the core action and dry-run default but leaves sibling relationships and operational prerequisites (e.g., draft must exist, CapCut closed) to the schema or inference.

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

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

Schema description coverage is 73%, so the schema already documents most parameters (volume scale, dry_run semantics, duration fallbacks). The description adds only the notion of volume and fade in/out, largely restating what the schema provides, so baseline 3 applies.

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

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

States a specific verb and resource ('Add music or a voice-over (audio file) on an audio track') plus capabilities (volume, fade in/out). An agent can tell this adds audio content. It does not, however, explicitly distinguish itself from siblings like capcut_add_clip or capcut_duck_music, which also touch the audio timeline.

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

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

The description implies when to use it (music/voice-over placement) and notes the default track is 'music'. But it gives no when-not guidance and does not route the agent to alternatives such as capcut_duck_music for background-music ducking or capcut_add_clip for generic media.

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

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

With no annotations, the description carries the behavioral load and does so well: it discloses the side effect (file copied into <draft>/assets/), which formats have readable length/size, that fade_in_s/fade_out_s reuse the capcut_set_clip audio-fade writer, and that video clips copy audio_fade onto video material. The dry-run-by-default behavior is a critical safety disclosure, though it is left to the last sentence.

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?

Purpose is front-loaded in the first sentence and every following sentence carries substance (side effects, format support, fade semantics, units, dry-run). It is slightly dense but contains 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?

For a 13-parameter mutation tool with no annotations and no output schema, the description covers purpose, side effects, format limitations and the dry-run default adequately. It could have said more about the write/return behavior in non-dry-run mode, but the essential call-time context is present.

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

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

Schema description coverage is already 92%, so the baseline is 3. The description adds genuine unit semantics ('Times are seconds') and cross-tool fade behavior, but it does not explain the majority of the 13 parameters (track layering, in_s vs start_s distinction, volume bounds), leaving most meaning 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 (Add) and resource (video, image or audio file to a draft timeline), which is more granular than the sibling capcut_add_audio. However it does not explicitly contrast itself with siblings like capcut_add_audio or capcut_add_clip-adjacent tools, so an agent still has to infer the boundary.

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

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

The description never says when to use this tool versus alternatives, nor does it state prerequisites or exclusions. The cross-reference to capcut_set_clip concerns fade behavior, not usage routing. Nothing tells the agent when to prefer capcut_add_audio or capcut_add_effect 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?

With no annotations, the description carries the full load and does disclose the important traits: frame-grid snapping, dry-run default, srt_out never overwriting, cues falling inside cuts being dropped, and place_subtitles=false skipping burned-in captions. It does not describe the returned time map format or failure/partial-write behavior, and the 'CapCut must be closed' requirement 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?

The purpose is front-loaded, which is good, but the text is a dense run-on of jargon ('the short cards', 'time map') and 'Dry-run by default' is stated twice, which wastes space. Sentences are long enough that the key constraint list is hard to scan.

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

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

For a 23-parameter batch operation with no output schema and no annotations, the description covers the core semantics well: keep vs cut, subtitle placement and remapping, SRT output, dry-run. The gaps are the unexplained time-map return value and the write-precondition details, but the essential mental model is present.

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

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

Schema coverage is 70%, so the schema already documents most parameters. The description adds real meaning only to a few (keep-entry shape and x/y/scale parity with capcut_set_clip, srt_out non-overwrite, place_subtitles, re-chunking) while leaving sub_color, sub_font_size, punch_words, min_gap_s, split_by, upper, volume and others unexplained. Baseline 3 is appropriate.

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

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

States a concrete verb and resource: batch-place the keep ranges (or everything but the cut ranges) of one source file back to back on a track and return the time map. It also disambiguates from siblings by anchoring its transform semantics to capcut_set_clip and its re-chunking to capcut_add_subtitles, so an agent can tell it apart from capcut_remove_segment or capcut_add_clip.

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 operating context (dry-run by default, place_subtitles false to skip captions, omit srt_out to skip the file) and references sibling tools for parity, but never states when to choose this over a single-segment tool like capcut_remove_segment or what the prerequisite state is. Usage is implied rather than explicitly bounded.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the call is dry-run by default and that real writes require CapCut to be closed, and it notes both example resources are free. It says nothing about what happens if the effects track is missing, whether an existing effect is replaced, or what the dry-run plan returns.

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

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

Front-loaded with the action and target, then the two modes and examples, ending with the dry-run default. Dense but every clause carries information; slightly overpacked with example IDs, though those earn their place given the opaque numeric resource_id format.

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

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

For a 9-parameter, nested-object mutation tool with no annotations and no output schema, the description covers the core action and the most confusing parameter but omits the return shape of the dry-run plan, failure modes, and the role of `name`/`track`. Adequate but with clear 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?

With only 44% schema description coverage across 9 params, the description usefully compensates: it maps `kind` to CapCut concepts, gives concrete resource_id examples with names, and 'over a time range' frames start_s/duration_s. It still leaves `name` and `track` unaddressed in prose, but adds real meaning beyond the schema for the highest-risk parameters.

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

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

States a specific verb and resource ('Add a CapCut video effect on an effect track over a time range') and immediately pins down the two modes, scene (video_effect) vs body (face_effect, follows people). This distinguishes it from siblings like capcut_add_filter, capcut_add_animation and capcut_add_transition without the agent needing to open other schemas.

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

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

The description clarifies which `kind` to pick and why (scene is a video effect, body follows people), and notes the operation is dry-run by default. It never says when to prefer this tool over capcut_add_filter or capcut_add_animation, nor what prerequisites (existing draft, CapCut closed) select it. Usage is implied rather than directed.

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

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

With no annotations, the description carries the full burden and does disclose two key traits: it overwrites the clip's existing filter (a destructive side effect) and it defaults to a dry-run. Missing are failure behavior (e.g. no clip at start_s) and permission/environment requirements, which are only hinted at in the schema's dry_run text.

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, front-loaded with the action and target, followed by the overwrite warning and the dry-run default. No filler and no repetition of schema constraints beyond what adds meaning.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description covers purpose, target scoping, destructive semantics, and the dry-run safety valve. Gaps remain around the undescribed name/track parameters and error conditions, but nothing essential for 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 only 43%, so the description has to compensate and largely does: it pins start_s to "the segment at start_s", bounds intensity to 0-100, and gives a concrete resource_id example (7668224318974823701 = Rollo vintage, free) plus its meaning. The name and track parameters remain unexplained anywhere, which keeps this below 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 names a specific verb+resource ("Put a CapCut filter") and narrows the scope to "one video clip (the segment at start_s)", which distinguishes it from sibling mutators like capcut_add_effect, capcut_add_sticker, or capcut_add_transition. An agent can tell what this does without 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?

Usage is implied rather than stated: you apply a filter to an existing clip identified by start_s, and the operation replaces any existing filter. There is no explicit guidance on when to prefer this over capcut_add_effect or capcut_insert_preset, and no prerequisites (e.g. that CapCut must be closed) are given in 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?

With no annotations, the description carries the full burden and does disclose the key behavioral trait: 'Replaces that property's keyframes' (a destructive, overwriting write) and 'Dry-run by default'. Unit conventions for every property are also given. It does not state permission needs, undo/reversibility, or the shape of the dry-run plan, so it adds substantial but not complete behavioral context.

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

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

The core action is front-loaded and every clause carries information (units, easing names, replacement semantics, dry-run default); there is no filler. It is dense and a single long run-on sentence, but nothing is wasted.

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

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

For a 7-parameter, 5-required mutation tool with no annotations and no output schema, the description covers replacement semantics, dry-run behavior, unit conventions and easing taxonomy. The main remaining gap is the absence of any description of what the dry-run plan returns, which matters given there is no output 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 only 43%, so the description must compensate, and it does: it defines the meaning and units of every value in the property enum (1 = half the canvas, scale 1 = 100%, degrees, alpha 0-1, -1..1 for brightness/contrast/saturation) and maps each ease value to CapCut's Aceleracion/Desaceleracion terms. Draft, track and the points/value payload are left 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 ('Animate one property of the segment at start_s'), which clearly separates it from sibling tools like capcut_add_animation or capcut_set_clip. The scope ('one property') is explicit. It stops short of naming an alternative sibling outright, 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?

Usage is implied by the scope statement and the dry-run default, but there is no explicit when-to-use/when-not, no mention of prerequisites beyond the write-time constraint, and no routing to alternatives such as the speed-curve or animation tools. An agent can infer the intent but gets no decision 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?

No annotations are provided, so the description carries the full burden; it does disclose the key behavioral trait that calls are dry-run by default, which is genuinely useful. But it omits other important behavior: that writing requires CapCut to be closed (only stated in the schema), whether existing markers are overwritten, and whether the mutation is reversible.

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: the action and payload come first, the dry-run default is front-loaded at the end as a warning. 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?

With no annotations and no output schema, the description must cover more ground. It handles the dry-run/write distinction and payload format, but does not describe what a dry-run returns, the CapCut-must-be-closed prerequisite (buried in the schema), or what happens to pre-existing markers.

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

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

Schema description coverage is 67% and the schema already documents draft, dry_run, and the marker properties. The description adds a useful inline example of the markers array shape and its semantic purpose (chapter points), but does not explain units/constraints for t_s or the meaning of color/title beyond what the schema says.

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 ('Add timeline markers (CapCut time marks)') and grounds it with a concrete use case (chapter points for a YouTube description) plus the payload shape [{t_s, title, color}]. It is clearly distinguishable from siblings like capcut_add_text or capcut_add_transition, though it never names an alternative for the marker/chapter domain (e.g. capcut_export_chapters).

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 through the example ('chapter points for a YouTube description') and the 'Dry-run by default' note, which tells the agent the safe starting mode. However, there is no explicit when-to-use/when-not guidance and no routing against the related sibling capcut_export_chapters, which an agent would plausibly confuse this with.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the tool is dry-run by default and that the sticker must already exist in CapCut's cache, but it omits permission requirements, reversibility, failure modes, and the fact (buried in the schema) that writing requires CapCut to be closed.

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

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

Three sentences, front-loaded with the core action before the prerequisite and the dry-run note. No filler, no repetition of the title, and each sentence adds a distinct fact.

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 an 11-parameter write tool with no annotations and no output schema, the description covers the decisive workflow facts (resource prerequisite, track, dry-run default, animation handoff). It is still thin on the remaining parameters and on what a dry-run versus real write returns, but the critical gaps are addressed.

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 27%, so the description must compensate. It clarifies the resource_id alias ('sticker_id'), the sticker track, and the position/scale/rotation group, but leaves name, duration_s, start_s, x/y, and track defaults unexplained beyond the schema itself.

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 ('Add a CapCut sticker on a sticker track by resource_id'), plus the key attribute group (position/scale/rotation). It also distinguishes itself from the animation sibling by routing that concern to capcut_add_animation, so an agent can separate this from capcut_add_effect/capcut_add_animation without opening a schema.

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

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

Gives a concrete precondition ('must have been added once in CapCut so it is in Cache/artistEffect') and names the follow-up tool for animation. It stops short of explicit when-not-to-use guidance or a direct contrast with the other 'add_*' siblings, so it is strong but not complete routing.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It does disclose meaningful traits: dry-run by default, re-chunking behavior, and that punch words get their own card. However it omits that writing requires CapCut to be closed (that detail lives only in the schema), the mutation/reversibility profile, and what the dry-run actually returns.

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

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

Three dense sentences that front-load the core action before detailing the optional re-chunking and positioning. The parentheticals about max_words/max_chars and split_by earn their place by clarifying behavior. Slightly packed but no wasted sentences.

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 16-parameter mutation tool with no annotations and no output schema, the description covers the primary features (SRT import, re-chunking, caps, punch cards, positioning, dry-run default). It leaves color, font_size, y, track, offset_s and min_gap_s to the schema, and says nothing about return values, but the safety-relevant default is surfaced.

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?

With 75% schema coverage the baseline is 3, but the description adds real meaning for the trickiest parameters: max_words/max_chars re-chunking, split_by ('time shared by letters or words on the frame grid'), upper (ALL CAPS), punch_words, and the x centring convention. This goes beyond the schema on the semantics that matter most for calling it correctly.

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: 'Import an SRT file (or SRT text) as caption text segments on one track.' That is far more than a restatement of the name. It references capcut_add_text for coordinate semantics, giving partial sibling differentiation, but does not explicitly distinguish itself from other text tools such as capcut_style_text or capcut_copy_text_template.

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 import framing and the note that dry-run is the default, but there is no explicit when-to-use/when-not guidance or named alternative (e.g. use capcut_add_text for free-form text instead of an SRT). The agent must infer routing from the resource being an SRT file.

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

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

With no annotations at all, the description carries the full burden. It usefully discloses that writes are dry-run by default and defines the x/y coordinate space, which are real behavioral facts. However it omits that the write path requires CapCut to be closed and says nothing about what a dry-run plan returns.

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

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

Three tight sentences with no filler, and the most important constraint (dry-run default) is placed prominently at the end of a short block. Slightly clipped, but 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?

For a 10-parameter mutation tool with no annotations and no output schema, the description leaves several gaps: units for timing parameters, the CapCut-must-be-closed precondition, and any hint of what is returned. It is adequate but not complete for the tool's complexity.

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 20% across 10 parameters, so the description must compensate. It adds meaning for x/y ('-1..1 from the canvas centre') and reinforces the dry_run default, but leaves start_s/duration_s units, color format, font_size, and track semantics to the raw 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 ('Add a text overlay ... to a draft') and gives concrete examples of the content type (title, hook, CTA). It is distinguishable from capcut_add_subtitles and capcut_style_text, though the description never names those siblings or clarifies the boundary.

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

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

Usage is implied (attach text overlays to a draft) and the dry-run default is called out, which is useful for knowing the safe path. But there is no explicit when-to-use versus when-not, no mention of prerequisites for real writes, and no routing to alternative text tools.

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

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

With no annotations, the description carries the full burden. It usefully discloses that it replaces an existing transition and that duration is capped at half the shorter clip, but omits auth/permission needs, whether the prior transition is discarded silently, and ordering constraints. The dry-run note largely duplicates 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?

A tight, front-loaded passage whose sentences all earn their place: action, location, identifier, constraint, default behavior in order. 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?

Adequate for a mutation tool: behavior, dry-run default, and the key numeric constraint are present, and the schema fills in the dry_run write prerequisite (CapCut closed). It falls short only on the unaddressed name/track params and any post-write confirmation detail.

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?

At 57% schema coverage the description adds real meaning: it annotates start_s as the clip boundary before the cut and gives a concrete reason to pass resource_id, plus the 'half the shorter clip' constraint for duration_s. name and track remain unexplained in both places.

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 (add/replace), resource (transition), precise location ('the cut after the video segment at start_s'), and the identifying key (resource_id). An agent can distinguish this cleanly from siblings like capcut_add_effect, capcut_add_filter, and capcut_add_animation.

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 usage via the location semantics and notes 'Add (or replace)' and 'Dry-run by default', but never states when to prefer this over alternatives or any prerequisites/exclusions. Context is present but no explicit routing guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses the dry-run-by-default behavior, but it does not say what the write path actually does to the timeline (merge vs keep segments), whether it is reversible, or what happens to overlapping/partially-inside segments – a meaningful gap for a mutation tool.

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, then the analogy, then the default behavior. 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?

For a mutation tool with no annotations and no output schema, the description covers purpose, range semantics, and the dry-run default, but omits the result of the write path and failure/prerequisite conditions (e.g. prior mention that CapCut must be closed lives only in the schema). Adequate but not complete.

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

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

Schema coverage is 60%; start_s and end_s carry no schema description, but the description supplies their critical semantics ('segments that lie fully inside start_s..end_s') and notes the single-video-track scoping for the track parameter. This compensates well for the undocumented range params, though the track default is left 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?

Specific verb+resource: 'Group the segments ... into a compound clip'. It scopes the operation to segments fully inside start_s..end_s on one video track, and the analogy to Option+G plus the bilingual name makes the intent unmistakable. No sibling tool does anything comparable, so it is clearly differentiable.

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 CapCut Option+G analogy and 'Dry-run by default' imply when and how to use it, but there is no explicit when-to-use vs alternatives, no prerequisites for the write path beyond the schema note, and no exclusions. 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?

No annotations provided, so description carries full burden. It discloses key behaviors: dry-run by default, fresh ids generated, new text optional, and can target same or different draft. Does not mention auth requirements or error conditions, but covers the critical mutation behavior well.

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

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

Single dense sentence front-loads the core operation and includes key details without waste. Every clause earns its place, from source/destination to ID behavior to dry-run default.

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 7-parameter mutation tool with no output schema, the description covers the essential workflow and safety (dry-run default). Missing some behavioral context like what happens to the original template or potential side effects, but reasonably complete.

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

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

Schema description coverage is 86%, so most parameters are documented in the schema. Description adds some semantic context about 'fresh ids' and 'optionally new text' but doesn't elaborate on parameter interactions or formats beyond what's in 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 (copy), resource (text template), and scope constraints clearly: from an existing draft segment to a new time, same or another draft. This distinguishes it from siblings like capcut_add_text (creating new text) by emphasizing copying an existing template with fresh ids.

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 usage through 'CapCut already placed in a draft' and 'optionally new text', but does not explicitly state when to use this vs capcut_add_text or other text tools. No when-not guidance or prerequisites mentioned.

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

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

With no annotations, the description carries full burden and does disclose genuinely non-obvious behavior: it copies version markers from a CapCut-made project so CapCut 9.x accepts the draft, and it defaults to dry-run. That is real value. It stops short of stating the write precondition (CapCut closed) in prose and does not mention naming collisions or failure modes.

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

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

Four short sentences, front-loaded with the action and defaults, then the non-obvious CapCut-9.x rationale, then the dry-run caveat. No filler; every sentence carries a distinct fact an agent needs.

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 mutating file-system tool with no annotations and no output schema, the description covers the key defaults, the template requirement, and the dry-run workflow. It is nearly complete, though a note on the write precondition and what the dry-run plan returns would round it out.

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 57%, so the description needs to compensate, and it does: it supplies the canvas and fps defaults (1080x1920, 30 fps) for the three undocumented numeric params and explains the reasoning behind template_draft ('auto' default, version markers for CapCut 9.x). It leaves register_in_index unexplained 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: 'Create a new empty draft folder.' The 'empty' qualifier distinguishes it from add_* tools that populate drafts. However it does not explicitly differentiate from the sibling capcut_register_draft, and the register_in_index parameter overlaps with that sibling's apparent purpose, leaving a small ambiguity.

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 it is a first-step tool via 'new empty draft' and 'Dry-run by default', which hints at a plan-then-write workflow. But it never states when to use this versus siblings like register_draft or make_short, nor any prerequisites. Usage is left to inference.

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

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

With no annotations, the description carries the load and does well: it discloses that it writes keyframes on disk, that dry-run is the default, and clarifies the under/free semantics. It omits prerequisites such as CapCut being closed and permission requirements, which the schema only partially covers.

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

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

A single dense, front-loaded sentence with a clarifying parenthetical; the core action leads and details follow. No wasted words, though the nested parenthetical is slightly crowded.

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 10-parameter, no-annotation, no-output-schema mutation tool, the description covers the core behavior and two key params but is silent on return/plan format and several parameters (ramp_s, merge_gap_s). Sufficient to start but not fully complete.

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

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

Schema coverage is 50%, so the description needs to compensate. It usefully explains 'under' (level during speech), 'free' (level between lines), and the default segment volume, but ramp_s, merge_gap_s, and track behavior are left to the schema, so it only partially closes the 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+resource (lower music under speech) and the exact mechanism (reads SRT cues, writes volume keyframes on the music track). This is clearly distinct from generic siblings like capcut_add_keyframes or capcut_add_audio, so an agent can select it without 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 scenario is implied by 'under speech' and 'reads SRT cues', so an agent can infer when it applies, but there is no explicit when-to-use/when-not guidance and no named alternative (e.g. vs. capcut_add_keyframes). Adequate but leaves routing to inference.

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

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

With no annotations, the description carries the full burden and delivers: fps snapping, the second-containing-frame rule, auto-insertion of a 00:00:00 line, three explicit refusal conditions, and the non-overwrite guarantee for out_path. These are exactly the behavioral traits an agent needs and none are recoverable from the schema.

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

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

Front-loaded with the core action, then the format, then the edge-case rules. Every sentence carries information, though the refusal rules and dry-run note are packed densely and could be ordered slightly more crisply. 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?

No output schema exists, so the description must describe the return value, and it does: a YouTube chapter list in HH:MM:SS Title form, plus the auto-inserted 0:00 line. For a tool with no annotations and no output schema, this is complete enough to call correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema: it clarifies that dry_run is the default when out_path is set and that out_path never overwrites, and it explains the purpose of zero_title (YouTube's 0:00 requirement). These enrich the parameters rather than restating them.

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 (read timeline markers, export a YouTube chapter list) and names its input source, capcut_add_markers. It is clearly distinguishable from siblings like capcut_export_srt and capcut_export_draft, and it even names the exact output format (HH:MM:SS Title).

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 context: it reads markers produced by capcut_add_markers, defaults to dry-run when out_path is set, and spells out the exact conditions under which it refuses to produce a list. It does not explicitly compare itself to capcut_export_srt or other export siblings, so routing between export variants still requires inference.

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

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

With no annotations the description carries the full burden, and it does disclose the two safety-critical traits unprompted: 'Never overwrites' and 'Dry-run by default.' It omits that CapCut must be closed and the index-backup behavior, but those facts do appear in the parameter descriptions.

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 zero filler; the core action leads and the caveats follow. Every sentence carries distinct 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 mutation tool with no annotations and no output schema, the description covers purpose, safety, and the skip condition, and the schema supplies the return-shape and precondition details. Reasonably complete, though the relationship to capcut_register_draft is left unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters including dry_run's default and register_in_index's caveat. The description adds only a restatement of the dry-run default, which is the correct baseline 3 when the schema does the heavy lifting.

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

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

States a specific compound verb (validate + copy) and resource (draft folder into CAPCUT_EXPORT_ROOT) plus the goal (open it in CapCut). It is clearly distinguishable from create_draft/add_clip siblings, though it never names the closely related capcut_register_draft it overlaps 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?

Gives an explicit when-not condition ('Not needed when CAPCUT_DRAFTS_ROOT already is the CapCut folder') and flags the dry-run default, which shapes invocation. It does not, however, route the agent between this tool and the sibling capcut_register_draft or explain the CapCut-closed precondition.

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

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

With no annotations, the description carries the full behavioral burden and does so well for the key traits: "Never overwrites" and "Dry-run by default" tell the agent the operation is safe-by-default. It omits that writing requires CapCut to be closed (left to the schema) and what a dry-run plan contains, keeping it short of a 5.

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

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

Three tight sentences with no filler, and the core action is front-loaded before the caveats. Every sentence carries distinct information (purpose, non-overwrite, dry-run default).

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 4-param export tool with no output schema and no annotations, the description covers the important safety and default behaviors. It is somewhat thin on preconditions (draft existence, CapCut closure) and return content, but nothing critical for correct invocation is missing.

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

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

Schema coverage is 75%, and the description adds meaning the schema lacks for the track parameter: it explains that the track defaults to "subtitles" and that exactly one track is targeted. Dry-run-by-default is also reinforced, though draft and out_path semantics 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 (write) and resource (cues of one text track as an .srt file), and clarifies the applicability (YouTube closed captions). It is clearly distinguishable from siblings like capcut_export_chapters and capcut_export_draft, though it never names those 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?

"e.g. for YouTube closed captions" gives one concrete use context, implying when this tool is appropriate. However, it never states when to prefer this over capcut_export_chapters/capcut_export_draft or any prerequisites, so routing is left to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose useful context: it reads a local preset store governed by CAPCUT_PRESETS_ROOT (defaulting to the CapCut Mac container) and that it is dry-run by default. It does not describe what the write does to existing tracks/clips, error behavior when the preset name is missing, or lock/permission requirements (the 'CapCut must be closed' constraint appears only in the schema's dry_run description).

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

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

Two dense sentences with the action front-loaded and the environment/dry-run caveats trailing. Minor redundancy with the schema's dry_run default, but nothing gratuitous.

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 disk-mutating tool with no annotations and no output schema. The description covers the preset source and the dry-run safeguard, which is the core of what an agent needs, but it omits what the plan/response contains and any side effects on the existing timeline, leaving gaps for a write operation.

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

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

Schema description coverage is 80%, so the schema already documents draft, track, preset and dry_run. The description only reinforces start_s ('at start_s') and the preset source; it adds no format, naming, or resolution semantics beyond the schema. 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 ('Insert'), a specific resource ('one of CapCut's saved elements'), and the resulting artifact ('as a compound clip at start_s'). The resource is unique among siblings (add_sticker, add_effect, compound_clip all differ), though the description never explicitly contrasts itself with the closest sibling, capcut_compound_clip.

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

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

Usage is implied by the resource: reach for this when you want a saved preset re-inserted into a draft. However there is no explicit when-to-use vs when-not-to-use guidance and no mention of the closest alternative, capcut_compound_clip, so the agent must infer the routing.

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

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

With no annotations, the description carries the full burden. It discloses the key behavioral trait '(read only)', which is useful, but omits other relevant behaviors such as return format, ordering, or whether listing is recursive. For a simple read-only list tool, this is partially adequate.

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 wasted words. The parenthetical '(read only)' adds relevant behavioral context without bloating the description.

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

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

For a zero-parameter, read-only list tool with no output schema, the description states what is listed and where. It could mention the return shape (e.g., a list of folder names) or ordering, but the essential information is present.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly does not need to explain parameters, and no additional parameter semantics are required.

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 ('CapCut draft folders in the drafts root'), clearly scoping the operation. This distinguishes it from sibling tools like capcut_read_draft (reads a draft) and capcut_create_draft (creates one).

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?

Provides no explicit when-to-use guidance or alternatives. It does not say when to prefer this over capcut_read_draft or other listing-related tools, leaving the agent to infer usage from the purpose alone.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that draft is 'filled in place' (in-place mutation of an existing project) and that the tool is 'Dry-run by default', but omits other material traits that live only in the schema (CapCut must be closed to write, register_in_index backs up root_meta_info first) and says nothing about error handling or reversibility.

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?

For a 38-parameter tool the description is compact and front-loads the core purpose before drilling into optional groups. It is a single dense run-on with nested parentheticals, which hurts parseability, but almost every clause carries routing or grouping 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?

No output schema exists and no annotations are present, so the description should ideally state what a dry-run returns, the write prerequisites, and the failure modes. It covers the compose target, draft-vs-name, and dry-run default, but the return contract and the write precondition (CapCut closed) are left to the schema, leaving the picture partial for a tool of this complexity.

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 63% (moderate), and the schema already documents most parameters richly. The description adds conceptual grouping (title/subtitle/music/re-chunking groups) and a valuable cross-reference that sub_style and title_style share the same fields and writer as capcut_style_text, but it leaves undocumented top-level params (title, sub_y, title_y, width, height) unexplained.

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 opening 'One call for a vertical short: clip + optional title + optional SRT subtitles + optional background music' gives a specific verb-equivalent (compose a vertical short) and enumerates exactly the resources it assembles. It implicitly positions itself above the single-purpose siblings (capcut_add_clip/add_subtitles/add_audio) but never names them, so differentiation is inferable rather than explicit.

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 real choice guidance between the two target modes ('Give draft ... or name ...') and flags the CapCut 9.x recommendation, plus the dry-run default. However it never says when to reach for this compound tool versus calling the individual sibling tools, which is the primary routing decision an agent faces.

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

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

No annotations are provided, so the description carries the full burden; it does declare the operation is read-only and specifies exactly what comes back, including that segment timing is in seconds. It omits error behavior (e.g., unknown draft name) and any limits on large timelines, but the core safety and output profile is disclosed.

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

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

One sentence, front-loaded with the verb and resource, with the return contents packed efficiently into the remainder. No filler or redundancy.

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

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

With no output schema, the description must convey return values and it does so explicitly. For a one-parameter read tool this is largely complete, though it could mention failure modes for a missing/invalid draft.

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

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

Schema description coverage is 100% for the single 'draft' parameter, which already explains it is the draft folder name from capcut_list_drafts. The description adds nothing beyond that, so the baseline of 3 applies.

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

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

States a specific verb (read) and resource (one draft) and enumerates the payload fields returned (canvas, fps, duration, timeline file, tracks/segments). It implicitly contrasts with the many mutating siblings via '(read only)', but never names capcut_list_drafts or capcut_export_draft, so sibling differentiation is only partial.

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 parenthetical '(read only)' implies this is the tool for inspecting a single draft without modification, but there is no explicit when-to-use guidance versus capcut_list_drafts (many drafts) or the export tools. 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?

With no annotations, the description carries the full burden and does well: it discloses the target file, that it is backed up first, the hard prerequisite that CapCut be closed, and that it is dry-run by default. It omits error/failure behavior and what happens to existing project-list entries on refresh.

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 sentences, front-loaded with the action and target, then timing, prerequisite, and safety default. Every sentence earns its place with no redundancy.

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

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

For a two-parameter tool with no output schema, the description covers the mutation target, backup, prerequisite, and dry-run output ('return the plan only'). It is largely complete, though it could say more about what a successful write returns or changes.

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

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

Schema description coverage is 100%, so both parameters (draft, dry_run) are already documented in the schema, establishing the baseline of 3. The description restates dry-run behavior and mentions 'current duration' (not a parameter) but adds no syntax or format detail beyond the schema.

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

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

States a specific verb pair (add/refresh) and resource (CapCut's project list / root_meta_info.json) with its current duration, making it distinguishable from siblings like capcut_create_draft or capcut_read_draft. It does not explicitly name an alternative sibling, 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?

Gives clear operational context: 'Run after the last edit' and 'CapCut must be closed', plus the dry-run-first posture. It does not explicitly contrast with create_draft or list_drafts, so it is strong context but not full when/when-not routing.

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

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

With no annotations, the description carries the full burden and does so well: it discloses that only orphaned materials are removed, that ripple moves later segments on the same track while other tracks stay put, and that it is dry-run by default. It omits irreversibility/undo and permission requirements, but the behavioral profile is unusually explicit.

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, front-loaded with the core action, followed by ripple behavior and the dry-run caveat. No filler, though the phrasing is dense enough that it borders on run-on.

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 six-parameter mutation tool with no annotations and no output schema, the description covers the essential action, cascade scope, ripple effect, and dry-run safety. Return-value detail is delegated to the dry_run schema field, which is reasonable; nothing critical to correct invocation is missing.

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

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

Schema coverage is 50%, so the description must compensate. It adds real meaning to ripple (default false, same-track-only pull-left) and clarifies start_s as the segment identifier, but leaves type, draft, and track essentially to the schema. Baseline 3 is appropriate given partial compensation.

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), a precisely identified resource (the segment starting at start_s on a named track), and the cascading target (materials only it used). This is unambiguous and easily distinguished from the many add_/set_ 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?

There is no removal alternative among the siblings, so the tool's role is implicit rather than contrasted. The description explains ripple semantics and dry-run default, which help the agent choose behavior, but it gives no explicit when-to-use/when-not guidance or prerequisites (e.g. draft must exist, CapCut closed for writes).

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

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

With no annotations, the description carries the full burden. It usefully discloses the layer-order model (position 0 = bottom) and the constraint that the main video track is pinned at 0, which is real behavioral context. However it omits what happens to the other tracks when one moves, error behavior for invalid positions or names, and any permission/locking requirement beyond what the schema already states about dry_run.

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 followed by the two facts an agent most needs (ordering semantics, dry-run default). No filler or restated name/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 mutation tool with no annotations and no output schema, the description covers the ordering model and dry-run default but not the shape of the dry-run plan, the write-side side effects, or failure modes. It is adequate but leaves the agent to discover return and error behavior by calling the tool.

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

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

Schema coverage is only 40%, with 'name' and 'position' undescribed in the schema. The description partially compensates by defining the meaning of position ('0 = bottom') and the grouping applied to 'type', but it never explains what 'name' refers to or how it identifies the track, leaving a key required parameter undocumented in both places.

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 ('Move a track up or down') plus the scoping rule ('among the tracks of its type'), so an agent immediately knows this reorders existing tracks rather than creating them. No sibling in the list does track reordering, so the action is effectively unambiguous, though the description never explicitly contrasts itself with neighbors like capcut_set_timeline.

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 or when-not guidance; the description only describes the operation and the dry-run default. It never says which sibling to prefer when restructuring a timeline, nor what precondition (existing track names) must hold before calling 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?

With no annotations, the description carries the burden and does disclose the key trait 'Dry-run by default', plus Pro-gated features (curves, color wheels, voice filter). It does not spell out what happens to unset properties or failure modes, but the dry-run default is meaningful safety context for a mutation tool.

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 verb+resource and scoping constraint are front-loaded, and the capability list, though long, is justified for a 29-parameter tool. It is a single dense run-on sentence, so a slightly more structured list would read better, but nothing is wasted.

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

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

For a 29-parameter mutation tool with 86% schema coverage and no output schema, the description covers the capability surface and the dry-run default adequately. It does not explain return behavior for dry-run, but the schema's dry_run text carries that, so the gap is minor.

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

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

Schema description coverage is 86%, so the schema already documents parameters thoroughly. The description's enumeration (scale/position/rotation/opacity, HSL, curves, etc.) maps to params but adds little syntax or meaning beyond what the schema provides; '(constant)' and '(8 colours)' are minor additions.

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 (Change) and resource (one clip, the segment at start_s on a track) and then enumerates exactly which clip properties it governs. This distinguishes it cleanly from siblings like capcut_set_speed_curve, capcut_add_filter, and capcut_style_text, which handle other aspects.

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 agent infers this is the tool for editing an existing clip's properties. There is no explicit when-to-use, when-not, or routing to alternatives such as capcut_set_speed_curve for variable speed (the '(constant)' hint is a nudge but not guidance), nor any stated prerequisites beyond what the schema carries.

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

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

With no annotations, the description carries the full burden and does well: it discloses the dry-run default, the Pro-tab caveat in CapCut 9.5, that export may require Pro, the null=1x reset, and the clip-length math (source / average speed, snapped to frames). It stops short of covering failure modes or what the dry-run plan 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?

Dense but front-loaded: the core action and its options come first, followed by caveats and the dry-run default. Some clauses are run-on, but every sentence carries information an agent needs.

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 mutation tool with no annotations and no output schema, the definition covers the critical behavioral facts (dry-run default, Pro requirement, reset semantics, length recomputation). Only the shape of the returned plan/response is unaddressed, which is minor given the dry-run framing.

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%, so the description has to compensate, and it does for the important parts: it defines the preset enum beyond the bare list, the custom-points shape (x 0..1, speed 0.1..10), and the null meaning. It leaves track and draft largely to the schema but adds real meaning over the raw fields.

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

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

States a specific verb and resource: setting a speed curve on one video clip identified by start_s. It enumerates the preset options and the custom-points form, so it is clearly distinguishable from siblings like capcut_set_clip or capcut_set_timeline.

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 explains the modes of the tool itself (preset vs custom points vs null-to-reset) and that dry-run is the default, which is useful. However, it never says when to reach for this tool instead of neighbors such as capcut_set_clip or capcut_add_keyframes, so sibling routing is left to inference.

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

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

With no annotations, the description carries the full burden, and it does disclose two non-obvious traits: the safe dry-run default and the destructive limit on duration (it cannot shorten existing segments). However, it omits other mutation-relevant behavior such as the requirement that CapCut be closed for a write (only visible in the schema), and what happens to unspecified settings.

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 zero filler; the operation and its target are front-loaded and the two caveats (duration limit, dry-run default) follow immediately.

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

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

For a 7-parameter mutation tool with no annotations and no output schema, the description covers the primary settings and the most important safety caveat, but leaves the write-safety precondition and side effects unexplained. It is adequate but not fully complete.

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

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

Schema coverage is only 43%, so the description must compensate. It maps to most writable parameters (canvas size = width/height, fps, duration, colour space) and clarifies that duration means 'total duration' rather than a segment, but it says nothing about the required 'draft' parameter or the fps/duration value ranges beyond what the schema already covers.

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

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

The description names a specific verb ('Change') plus the exact settings affected (canvas size, fps, total duration, colour space) on a named resource (a draft), so an agent can distinguish it from capcut_set_clip or capcut_set_speed_curve. It does not explicitly name a sibling it is differentiated from, which keeps it short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as capcut_create_draft or capcut_set_clip, nor any prerequisites (e.g. CapCut must be closed). The only usage-relevant statements are constraints ('Duration cannot cut existing segments') and the dry-run default, not routing information.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that dry-run is the default, a significant behavior for a mutation tool. But it omits that CapCut must be closed for a real write (only in the schema), whether changes are reversible, and the wordart/stroke mutual exclusion.

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 dense sentence, front-loaded with the core purpose followed by the feature inventory, then scope and dry-run behavior. For a 29-parameter tool this is efficiently sized with little waste.

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

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

There is no output schema and no annotations, so the description must do more. It covers the main capability and the dry-run/scope behavior, but omits the CapCut-must-be-closed requirement and the wordart/stroke incompatibility, leaving an agent to discover these from the schema 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?

At 59% schema coverage with 29 params, the description adds value by naming the styling features (WordArt, stroke, shadow, background box, per-word highlight, font file, wrap width, alignment). It leaves several params (glow, bubble, line/letter spacing, bg offsets) unmentioned and does not restate the wordart-vs-stroke conflict documented in 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 ('Style text already on a track') and correctly scopes to captions/titles, implicitly distinguishing it from capcut_add_text which creates text. It enumerates the styling axes covered. It does not explicitly name the sibling tools it competes with, so it stops short of the top tier.

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 clarifies scope ('All segments on the track, or only the one at start_s') and that it dry-runs by default, which implies the safe-preview workflow. However there is no guidance on when to prefer this over capcut_copy_text_template or capcut_add_text, and no prerequisites stated.

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