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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it offers none: nothing about required project/sequence state, whether the track must already exist or be unlocked, whether the layer is placed at the playhead or at startTime, whether the operation is undoable, or what is returned. Only the 'video track' constraint is conveyed.

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

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

It is a single front-loaded sentence with no filler, which is structurally clean. Its brevity, however, edges into under-specification rather than genuine economy given the density of adjacent sibling tools.

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 zero annotation coverage and no output schema, the description should say at minimum what state is required and what the call returns or affects. Neither is present, leaving an agent unable to predict side effects or failure modes before invoking it.

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

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

Schema description coverage is 100%, with every parameter (name, duration, startTime, trackIndex) documented including units in seconds, so the schema does the heavy lifting. The description adds only the small clarification that trackIndex refers to a video track; a baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Add an adjustment layer') plus the target container ('to a video track'), so the basic action is unambiguous. It does not, however, distinguish this from the cluster of sibling creation tools such as add_color_matte, add_black_video, add_bars_and_tone, or apply_effect, which an agent must choose between.

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 an adjustment layer versus a color matte, an applied effect, or a text graphic, and no stated prerequisites such as an active sequence, an existing video track, or where on the timeline the layer lands. The agent must infer all of this from sibling names 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It says only that a keyframe is added, without explaining duplicate-keyframe behavior, required permissions, whether changes are undoable, or what the response 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?

It is a single front-loaded sentence with no filler. The action, target, and key input concept are all expressed efficiently.

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

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

For a simple four-parameter mutation tool with fully documented schema fields, the description is adequate to identify the operation. However, with no annotations or output schema, it should say more about mutation behavior and alternatives.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description reinforces that the operation targets audio volume at a specific time but adds no format, range, or edge-case semantics beyond that.

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

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

The description states a specific verb and resource: adding an audio volume keyframe to a clip at a given time. It is clear what the tool does, though it does not explicitly differentiate itself from sibling tools such as add_keyframe or set_clip_volume.

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

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

The description provides no guidance on when to use this tool instead of alternatives like add_keyframe or set_clip_volume. It implies usage from the name and purpose but includes no exclusions or routing advice.

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 disclosure burden, and it discloses nothing beyond the action. It does not say whether the bars land at the playhead or the given startTime, whether existing material is overwritten or rippled, whether audio tone requires an audio track, or whether the operation is undoable. For a timeline-mutating tool with zero annotation coverage this is a real gap.

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

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

A single tight sentence with no filler, and the action is front-loaded. It is efficient, though efficiency here partly reflects under-specification rather than disciplined editing.

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?

Three fully-documented required parameters and no output schema make this a simple tool whose structural fields cover the mechanics. What is missing is the behavioral layer — overwrite semantics and track-type requirements — which matters for an unannotated mutation on a live timeline.

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% — units (seconds) and the meaning of trackIndex are already documented in the schema — so the baseline is 3. The description adds no constraint such as track-type validity or start-time behavior, so it earns nothing above baseline.

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

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

Specific verb (add) plus a specific resource (color bars and tone) and destination (the timeline). This distinguishes it from nearby siblings such as add_color_matte, add_black_video, and add_universal_counting_leader, though it never names those alternatives.

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

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

No indication of when this should be used versus the other synthetic-media generators in the sibling list, no prerequisites (active sequence required?), and no exclusions. The agent must infer everything about selection context.

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

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

With no annotations, the description carries the full behavioral burden. It doesn't say whether the clip is inserted or overwritten, whether it requires an active sequence or unlocked track, what default properties the black video gets, or what is returned. 'Add' implies mutation but nothing about side effects 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?

A single short sentence with the verb and target front-loaded; nothing is padded. It is arguably too terse rather than verbose, but every word present 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, no output schema, and three positional parameters, the description leaves key questions open: insertion vs overwrite behavior, required context (active sequence, track state), and the resulting clip's defaults. It is too thin given the 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 100% — duration, startTime and trackIndex are each documented in the schema. The description adds nothing about parameter meaning, so the baseline 3 applies.

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

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

Names a specific verb and resource ('Add black video ... to the timeline'), so the action is unambiguous. It doesn't distinguish itself from similarly-generative siblings such as add_color_matte or add_adjustment_layer, and the parenthetical '(slug)' is unexplained jargon that adds no clarity.

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

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

There is no statement of when to use this versus add_color_matte, add_bars_and_tone, or add_clip_to_timeline, and no prerequisites (e.g. an active sequence must exist). The agent must infer the use case from the name alone.

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

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

With no annotations, the description carries the full behavioral burden for a mutation tool. It does not say whether the target track must exist, how overlapping or out-of-order time ranges are handled, whether the change is undoable, or what the response 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?

A single efficient sentence with no filler and the action front-loaded. However, that brevity is achieved by omitting useful context rather than by tight writing.

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-parameter mutation tool with no annotations and no output schema, the description is too thin. It omits prerequisites (existing caption track), timing/ordering constraints, and any behavioral notes an agent would need to call it safely.

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

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

Schema description coverage is 100%, so all four parameters (startTime, endTime, text, trackIndex) are already documented in the schema including units and the default track index. The description adds no meaning beyond those field-level descriptions, making the baseline 3 appropriate.

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

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

The description uses a specific verb+resource pair ('Add a caption/subtitle segment to a caption track'), which clearly separates it from siblings like update_caption, remove_caption, and add_caption_track. It just stops short of explicitly naming how it differs from those siblings.

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

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

There is no statement of when to use this versus update_caption or add_caption_track, and no prerequisites are given. An agent must infer that a caption track must already exist before a segment can be added.

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 says nothing about whether a caption track must already exist for trackIndex, whether existing captions are overwritten, whether the operation is undoable, or what is returned — all material for a mutation tool that adds timeline items.

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

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

Two sentences, front-loaded with the operation and followed by the caption structure. The marketing-flavored 'perfect for' clause is mild filler but does convey legitimate use cases, so little 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?

The schema fully documents the six parameters and there is no output schema, so the description needn't explain return values. But for a timeline-mutating batch tool with zero annotations, the absence of any note on caption-track prerequisites or overwrite behavior leaves a real gap.

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

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

Schema description coverage is 100%, so all six parameters (including defaults for scale, template, positionX/Y) are already documented. The description only restates that each caption has text, start, and duration, adding no semantics 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 and resource ('Add multiple timed text captions in sequence') and clarifies the batch nature versus a single-caption call. It does not, however, distinguish itself from close siblings like add_caption or add_tiktok_caption, even though it explicitly invokes the 'TikTok-style captions' use case that the latter presumably owns.

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

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

Use cases (word-by-word captions, lyrics sync, subtitle overlays) imply when the tool fits, but there is no explicit when-not guidance and no named alternative for single captions or for the TikTok-specific sibling. The agent must infer routing from the examples.

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 reveals only that the target is the active sequence; it does not address what happens if the track already exists, whether an active sequence is required, failure behavior, permissions, or any side effects of adding a track.

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

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

The description is a single front-loaded sentence with no filler. It states the action and target immediately and wastes no words.

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

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

The tool is a simple mutation with one optional enum parameter and no output schema. The description adequately states the main action, but without annotations it should do more to explain usage distinctions and behavioral expectations. It is minimum viable rather than complete.

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

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

Schema description coverage is 100%, so the single optional format parameter and its enum values are already fully documented in the schema. The description adds no additional parameter semantics, which is consistent with the baseline 3 under high schema coverage.

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

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

The description gives a specific verb and resource: 'Add a new caption/subtitle track' and scopes it to 'the active sequence.' It is clear what the tool does, though it does not explicitly distinguish itself from sibling tools like add_caption or add_caption_sequence.

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 states the action but gives no guidance on when to choose it over related tools such as add_caption, import_captions, or add_caption_sequence. There are no exclusions or prerequisite notes beyond the implied requirement of an active sequence.

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 identifies the operation as an addition but does not disclose permissions, whether the marker persists or is undoable, index expectations, or what happens if the clip does not exist.

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?

It is a single front-loaded sentence with no wasted words. The action and target are immediately clear even if further detail is absent.

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 seven parameters, no annotations, and no output schema, the description is too thin. It does not explain index conventions, required permissions, return behavior, or how it relates to the other marker tools in the sibling list.

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

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

Schema description coverage is 100%, so all seven parameters including time, trackType, trackIndex, and clipIndex are already documented in the schema. The description adds no additional meaning beyond that structured documentation.

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

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

The description states a specific verb and resource: 'Add a marker to a specific clip on the timeline.' This distinguishes it from sequence-level or project-item marker tools by scoping the marker to a clip, but it does not explicitly name the sibling alternatives like add_marker or add_project_item_marker.

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 add_marker, add_project_item_marker, or update_marker. The clip-specific scope is implied by 'specific clip,' but no conditions, exclusions, or alternatives are 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 are provided, so the description carries the full burden, and it discloses almost nothing. "Insert edit" hints at ripple behavior to an expert, but the description never states that existing clips are pushed downstream, what happens on failure, or whether the operation requires an open sequence.

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

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

A single, front-loaded sentence with no filler, so nothing is wasted. The terseness borders on under-specification rather than excess, but structurally it is efficient.

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

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

This is a mutation tool with no annotations and no output schema, and the description supplies no behavioral or contextual detail. Even though the parameters are fully documented in the schema, an agent still lacks information on ripple semantics, required preconditions, and error behavior.

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

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

Schema description coverage is 100%, including per-field descriptions and an enum for trackType, so the schema already documents all six parameters. The description adds no additional meaning (e.g., how inPoint/outPoint interact with startTime), which is the baseline-3 case.

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 project item (clip) to the timeline") and adds an edit mode ("via insert edit") that implicitly distinguishes it from the sibling overwrite_clip_to_timeline. It falls short of a 5 because the insert-vs-overwrite distinction is only implied through jargon rather than stated as a contrast.

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

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

There is no explicit when-to-use or when-not-to-use guidance. The description never names overwrite_clip_to_timeline or any other alternative, nor does it state prerequisites such as needing an active sequence or the clip already existing in the project.

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 says nothing about mutation effects: whether the item is created at the playhead or at startTime, whether it can be undone, whether it requires an open sequence, or what it returns. Only the bare action 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?

A single front-loaded sentence with no waste, but its brevity comes at the cost of the missing context rather than through efficient compression. Adequate rather than well-crafted.

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 five parameters, no annotations, and no output schema, the definition should at least state that an active sequence is required and how placement works. As written, an agent must infer the entire operational context.

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

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

Schema description coverage is 100%, so every parameter (name, color hex with default black, duration, startTime, trackIndex) is already documented in the schema. The description adds nothing about placement, defaults, or constraints, which is acceptable at baseline given the schema's completeness.

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 plus resource ('Add a color matte') with a clarifying gloss ('solid color') and the target ('timeline'). It stops short of distinguishing itself from near-siblings like add_black_video or add_adjustment_layer, which also create generated timeline items.

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

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

No indication of when to use this versus add_black_video (a black matte is a color matte), add_adjustment_layer, or add_bars_and_tone. No prerequisites such as requiring an active sequence are stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It implies a mutation but does not disclose whether an existing keyframe at the same time is overwritten, what the default interpolation is, what permissions are required, or what happens if the property is not keyframable.

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

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

The description is a single front-loaded sentence with no wasted words. It states the core action and scope immediately, though the resulting brevity leaves behavioral gaps that are better assessed under contextual completeness.

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 seven-parameter mutation tool with no annotations and no output schema, the description is too thin. It does not explain keyframe replacement behavior, interpolation defaults, error conditions, or what the tool returns, leaving the agent without enough context to call it confidently.

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 seven parameters, including time units and track type enum. The description only restates the idea of a specific time and adds no syntax or meaning beyond the schema, making the baseline 3 appropriate.

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

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

The description uses a specific verb and resource: it adds a keyframe to an effect property at a given time. This clearly distinguishes it from add_audio_keyframe, but it does not explicitly name or differentiate against siblings like get_keyframes, remove_keyframe, or set_keyframe_interpolation.

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 add_audio_keyframe, set_effect_property, or set_keyframe_interpolation. It also omits prerequisites, such as whether the effect property must already exist or be keyframable.

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 very little: it doesn't state that this mutates project state, that it fails without an active sequence, whether a time outside sequence bounds is rejected, or what is returned. Only the 'active sequence' target 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?

A single front-loaded sentence with no waste, appropriately sized for a simple create operation. It is efficient but borders on under-specified rather than maximally informative.

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

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

The full parameter schema compensates for the lack of parameter detail, and there is no output schema to explain. However, for a mutation tool with eight parameters and zero annotation coverage, the description leaves behavioral expectations (errors, active-sequence requirement, effect on the timeline) 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% and all eight parameters, including the two enums and the markerType-dependent url/frameTarget fields, are documented in the schema itself. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ("Add a marker") plus scope ("to the active sequence"), which implicitly separates it from add_clip_marker and add_project_item_marker. It never names those siblings explicitly, so differentiation relies on the agent noticing the scope phrase.

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 scope phrase implies when this tool applies (a marker on the active sequence rather than on a clip or project item), but there is no explicit when-to-use vs. alternative guidance and no stated prerequisites such as an open project or existing active sequence.

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 for a mutation tool. It does not disclose whether the target track must exist, whether insertion overwrites existing clips, permission requirements, or what happens on invalid track indices or paths.

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 single sentence is front-loaded with the action and resource, and there is no wasted text. Its brevity is appropriate, though the definition is under-specified rather than optimally structured.

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 four-parameter mutation tool with no annotations and no output schema, the description is too sparse. It omits prerequisites, side effects, error conditions, and return behavior, leaving the agent to infer how insertion interacts with existing timeline content.

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

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

Schema coverage is 100%, and all four required parameters have descriptions in the schema, so the schema already does the heavy lifting. The tool description adds no additional meaning about units, acceptable index ranges, or path format beyond what is 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?

The description states a specific verb (add) and resource (.mogrt) and scopes it to the timeline. It is clear enough to distinguish from import_mogrt by implication, though it does not explicitly name or contrast sibling timeline insertion tools such as add_clip_to_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?

Usage is implied by 'to the timeline': the agent can infer this inserts a template into an existing sequence rather than importing it. However, there is no explicit guidance on when to use this versus import_mogrt, add_clip_to_timeline, or set_mogrt_property after insertion.

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 says only that a marker is added and does not disclose mutation side effects, permission requirements, duplicate-marker behavior, persistence, or what a successful call 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?

The description is a single front-loaded sentence with no wasted words. The important scope clarification is placed immediately after the core action.

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

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

For a simple add-marker operation with fully documented parameters and no output schema, the description provides enough scope for correct invocation. The main missing context is behavioral rather than structural, which is already reflected in the behavioral transparency score.

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 five parameters including name, time, color, nodeId, and comment. The description adds no parameter-level meaning beyond that, making the baseline 3 appropriate.

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

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

The description uses a specific verb and resource ('Add a marker to a project item') and immediately clarifies scope with '(source clip, not timeline)'. This lets an agent distinguish it from timeline marker siblings such as add_marker and add_clip_marker without opening 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?

It gives clear context by specifying source clip usage and explicitly excludes timeline markers. However, it does not name the alternative tool to use for timeline markers, so it falls short of full when-to-use/when-not/alternatives guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure and largely drops it. It does not say whether an active sequence is required, whether the tool creates or returns a graphic object whose identifier is needed for later styling, or what happens when trackIndex is invalid or the track is occupied at startTime.

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

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

A single front-loaded sentence with no filler. It is efficient and easy to parse, though its brevity contributes to the missing context elsewhere rather than being deliberately selective.

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 ten-parameter timeline mutation with no annotations and no output schema, the definition is thin. It leaves out sequence prerequisites, the relationship to style_text_graphic (likely the follow-up call on the created graphic), and any hint of the return value, which the agent would need to chain calls.

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 ten parameters including units and coordinate normalization. The description adds no parameter meaning beyond that, which makes the baseline 3 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 specific verb ('Add') and specific resource ('text graphic / Essential Graphics') with its destination ('to the timeline'). It does not, however, distinguish itself from close siblings like style_text_graphic, add_mogrt_to_timeline, or add_tiktok_caption, so an agent cannot tell from the description alone which of these to reach for.

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 versus add_mogrt_to_timeline or style_text_graphic, nor any prerequisite such as needing an active sequence or a valid video track. The agent must infer all of this from the name and schema 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 burden, and it does disclose one genuinely useful trait: this creates a MOGRT-based title graphic rather than a real caption-track entry, which matters for later get_captions/update_caption calls. It says nothing about prerequisites (active sequence, MOGRT availability), return value, or whether the placement is undoable, so the mutation profile is still thin.

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, purpose front-loaded, zero padding or repetition. The third sentence is slightly promotional ('Great for...') but it does carry use-case signal, so it mostly 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 an 8-parameter timeline-mutating tool with no annotations and no output schema, the description covers what it makes and roughly why, and the schema covers the parameters. What's missing is disambiguation from sibling text/caption tools and any statement of what the call returns or requires, leaving the agent to guess.

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

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

Schema description coverage is 100% and every parameter, including the template enum and the positionX/positionY conventions, is documented in the schema. The description adds only a soft hint about 'big bold text' that loosely maps to the scale parameter, 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 a TikTok-style text caption to the timeline') and even names the mechanism (built-in Premiere Pro title MOGRTs), so the agent knows exactly what gets created. It does not, however, distinguish itself from siblings like add_text_graphic or add_mogrt_to_timeline, which sound like near-equivalents.

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?

'Great for adding big bold text overlays, word highlights, or captions' gives use-case context, which is more than nothing. But there is no when-not guidance and no mention of the obvious alternatives (add_text_graphic, add_caption, add_caption_track), so the agent must infer selection criteria on its own.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says the tool adds tracks but does not disclose whether an active sequence is required, whether the operation is undoable, what happens if tracks already exist, or what the response 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?

The description is a single, front-loaded sentence with no redundant or wasted text. It states the action and target efficiently.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin. It omits prerequisites, side effects, undo behavior, and return expectations, leaving key operational context unstated.

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 position, audioTracks, and videoTracks. The description adds no parameter-level meaning beyond what the schema provides, making baseline 3 appropriate.

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

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

The description clearly states a specific verb and resource: adding video or audio tracks to the active sequence. This distinguishes it from remove_track and other sequence tools, though it does not explicitly name or contrast with alternatives.

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 implies the tool operates on an active sequence but gives no explicit when-to-use guidance, prerequisites, or alternatives such as create_sequence. An agent must infer when this is appropriate versus other track or sequence operations.

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 implies a mutation to the timeline but gives no information about permissions, whether the leader is inserted or overwritten, its default duration, or any side effects.

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 efficiency is appropriate for a simple two-parameter operation, though the result is under-specified rather than overly concise.

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 timeline-mutating tool with no annotations and no output schema, the description omits critical context: what the counting leader is, how it is placed on the track, whether it has a fixed duration, and what happens if the track is occupied.

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

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

Schema coverage is 100%, with both startTime and trackIndex fully documented in the schema. The description adds no meaning beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb (Add) and a specific resource (universal counting leader) applied to the timeline. The resource name itself differentiates it from siblings like add_bars_and_tone or add_black_video, but it does not explicitly disambiguate its scope versus those alternatives.

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 add_bars_and_tone, add_black_video, or add_adjustment_layer. It only states the action, leaving the agent to infer the appropriate context.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about whether the operation is destructive, what happens if a crossfade or transition already exists, whether clip in/out points or durations are modified, or what the response is.

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

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

A single front-loaded sentence with no filler. It is efficiently written, though the terseness leaves little room for the behavioral context a mutation tool 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?

A timeline-mutating audio operation with no annotations and no output schema needs more than one sentence. Missing are the effects on existing transitions, whether the operation is reversible or undoable, and any indication of what is returned on success.

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 enum of fade types, durations and both indices are already fully documented in the schema. The phrase 'between two adjacent clips' reinforces that clipIndex refers to the first clip, but adds no syntax or format detail 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 (apply), resource (audio crossfade) and scope (between two adjacent clips), which separates it from apply_transition and apply_effect in the sibling list. It never names an alternative explicitly, 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?

'Between two adjacent clips' implicitly states the precondition that the clips must be adjacent, which is real usage guidance. However, it never says when to use this versus apply_transition or set_clip_in_out, nor when not to use it, so the guidance is only implied.

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

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

With no annotations, the description carries the full burden. It does not disclose that this is a mutating operation, whether it can be undone, whether effectName must match an existing effect (discoverable via get_video_effects_list / get_audio_effects_list), or what happens on failure.

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 waste. It is efficient, though its brevity is partly the reason behavioral gaps remain.

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 four-parameter required mutation tool with no annotations and no output schema, the definition is too thin. It omits prerequisites, effect name sourcing, and the relationship to sibling effect-management tools.

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

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

Schema coverage is 100%, so parameter meaning is fully documented in the schema. The description only reinforces the video/audio effect domain and adds no format or constraint detail beyond the schema's enum and effect examples.

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 — applying a video or audio effect to a timeline clip — which is clear on its own. It stops short of distinguishing itself from nearby siblings like set_effect_property, remove_effect, or get_clip_effects, so an agent must 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?

No guidance on when to use this versus set_effect_property (which modifies an existing effect) or how to discover valid effect names. It implicitly assumes the clip already exists and the effect is valid, but never says so.

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, and it discloses almost no behavioral traits. It does not say whether applying over an existing transition replaces or errors, whether the action is undoable, whether track/clip must already be selected or active, what permissions/state are required, or what the call returns on success or failure.

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 tight sentence with the core action and its two placement cases front-loaded; no filler, no restatement of the name.

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 timeline-mutating tool with zero annotations and no output schema, the description is too thin: it omits how to obtain a valid transitionName, collision behavior with existing transitions, and any success/failure signaling. The schema covers the inputs well, but the agent has no behavioral picture of the 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 coverage is 100% with per-parameter descriptions and two enums, so the schema already explains duration, position, trackType, trackIndex, clipIndex, and transitionName in detail. The description adds nothing on top, 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 concrete verb (apply) and resource (video/audio transition) plus the placement context ('between two adjacent clips or at a clip edge'), which is enough to distinguish it from remove_transition, set_default_transition, and apply_effect. It stops short of naming those siblings or pointing at get_video_transitions_list / get_audio_transitions_list as the way to obtain a valid transitionName.

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: an agent infers it should call this when a cut needs a transition, and that transitionName must be a valid effect name. There is no explicit when-to-use vs. remove_transition / set_default_transition / apply_audio_crossfade, and no stated prerequisite that the name should come from the transitions list 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?

No annotations are provided, so the description carries the full burden. It does not say whether proxy mode must already be enabled, whether this mutates or replaces an existing proxy attachment, whether the path must be reachable, or how failures surface.

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 eight-word sentence with the action front-loaded and no filler. It is efficient, though its terseness is part of why behavioral context is thin.

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 mutation tool with no annotations and no output schema, the definition is minimally sufficient to call it. It omits interaction with proxy mode and the create_proxy/toggle_proxy_mode workflow, which an agent would need to avoid mis-sequencing.

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

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

Schema description coverage is 100%, with both nodeId and proxyPath documented in the schema. The description adds only the mild nuance that proxyPath must reference an existing file; it gives no format, path-resolution, or nodeId-selection 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 and resource ("Attach existing proxy media") plus the target ("a project item"). The word "existing" implicitly separates it from create_proxy, which generates proxy media rather than binding one, though no sibling is named 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?

Usage is only implied: "existing proxy media" suggests the caller already has a proxy file on disk. There is no explicit statement of when to choose this over create_proxy or toggle_proxy_mode, and no prerequisites are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions AI-powered reframing and the active sequence context, but does not state whether the original sequence is modified or a new sequence is created, what permissions are needed, or whether the operation 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?

The description is a single, front-loaded sentence that states the core action and target without any extraneous information. It is appropriately sized for a tool whose parameters are fully documented in the schema.

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

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

With no annotations and no output schema, the description should clarify key behavioral details for a potentially significant operation. It does not explain whether a new sequence is created, what happens to the active sequence, or what the result of the operation is, leaving important context gaps.

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

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

The schema has 100% description coverage, so all parameters including numerator, denominator, newName, motionPreset, and useNestedSequences are already documented. The description adds only the high-level concept of a target aspect ratio and does not provide additional parameter semantics beyond the schema.

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

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

The description clearly states a specific verb ('Auto-reframe') and resource ('the active sequence') with the target ('new aspect ratio'). It distinguishes itself from general sequence settings tools by specifying AI-powered reframing, though it does not explicitly differentiate from closely related sequence operations like set_sequence_settings.

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

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

The description implies the tool operates on the active sequence but provides no explicit guidance on when to use it versus alternatives, prerequisites such as having an active sequence, or conditions where it should not be used. No sibling tools are named as alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does convey useful scope — 'all' markers on the 'active sequence' only, implying clip/project-item markers are untouched — but says nothing about irreversibility, undo support, or confirmation behavior for a destructive bulk operation.

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

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

A single front-loaded sentence with no filler, appropriately sized for a zero-param operation. It is efficient but bare enough that a little more behavioral detail would not have hurt.

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

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

For a simple no-argument tool this covers the essentials, but with no annotations and no output schema, the description leaves gaps around destructiveness, undo, and what state remains afterward — context an agent making a bulk-destructive call would want.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies.

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

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

States a specific verb and resource ('Remove all markers') plus the scope ('active sequence'), which implicitly separates it from the singular sibling remove_marker and the clip/project-item marker tools. It does not explicitly name those siblings, so it stops short of a 5.

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

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

Bulk-clearing is implied by 'all', but there is no explicit guidance on when to use this versus remove_marker, nor prerequisites such as having an active sequence open. Usage must be inferred from the name and scope.

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. 'Clear' implies removing in/out marks, but the description doesn't say whether the operation is reversible, whether it clears both marks or only the ones present, or what permissions or item state are required.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though the brevity edges toward under-specification rather than optimal conciseness.

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

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

The tool is simple (one param, no output schema, no annotations), and the description covers the basic effect. It still leaves open the scope question (project item only? affects timeline placement?) and the reversibility question, which matter for a state-clearing 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?

There is a single parameter with 100% schema description coverage, so the schema already defines nodeId as the project item identifier. The description adds no syntax or format detail, which is the expected baseline when the schema is fully documented.

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

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

The description states a specific verb ('Clear') and resource ('in/out points on a project item'), so an agent knows exactly what it modifies. It does not explicitly contrast with the sibling set_project_item_in_out or the sequence-level clear_sequence_in_out, but the name plus target scope makes the distinction reasonably clear.

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

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

There is no guidance on when to use this versus set_project_item_in_out (to set) or clear_sequence_in_out (for a sequence rather than a project item). The agent must infer the usage context entirely from the tool name.

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 confirms scope (active sequence only) but omits whether clearing in/out points is undoable, what happens when no in/out points are set, and whether clips are affected — meaningful gaps for a destructive mutation.

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 tight sentence with the resource and scope front-loaded; nothing is wasted.

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

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

For a zero-param tool with no output schema the description covers what it does and where, but given the absence of annotations it leaves callers unsure about preconditions and reversibility.

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

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

Zero parameters, so there is nothing for the description to compensate for; baseline 4 applies.

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

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

States a specific verb ('clear') plus the exact resource ('in and out points') and scopes it to 'the active sequence', which implicitly separates it from clear_project_item_in_out and set_sequence_in_out. It stops short of naming any sibling explicitly.

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

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

The intended action is obvious from the name, but there is no explicit when-to-use, no mention of prerequisites (an active sequence must exist), and no reference to the alternative set_sequence_in_out for setting rather than clearing.

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 disclosure burden for a mutating operation, yet it says nothing about what gets copied (clips, tracks, markers, settings, effects), where the clone lands, or what happens if newName is omitted or collides. Only the bare fact of duplication is conveyed.

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

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

A single sentence with no padding, which is efficient, but it is so terse that it lacks any structure or front-loaded detail beyond the bare action. Nothing is wasted, but nothing is added either.

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, no output schema, and no stated return value, the description leaves key behavior (what is duplicated, whether the clone becomes active, error cases) undefined. An agent can guess the call, but cannot predict the outcome.

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 newName and sequenceName are already documented in the schema, giving the baseline of 3. The description adds nothing beyond that, and notably does not explain the consequence of the optional fields being unnamed (required count is 0).

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?

Clear verb ('duplicate') plus resource ('sequence') tells an agent exactly what the tool does at a glance. It does not distinguish itself from nearby siblings such as create_sequence, create_sequence_from_clip, create_subsequence, or import_sequences, which is the only thing keeping it from 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?

The description offers no guidance on when to use this instead of create_sequence, import_sequences, or create_subsequence, and no prerequisites (existing sequence required, name uniqueness). Usage must be inferred entirely from the name.

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 for a destructive operation. It implies saving is optional but never says whether unsaved changes are discarded, whether the user is prompted, whether closing is reversible, or what errors occur when no project is open.

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 action and resource, with no filler. The parenthetical is slightly ambiguous but compact.

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 project-closing tool with no annotations and no output schema, the description omits the critical data-safety semantics (discard vs. prompt when save=false) and assumptions about an active project. These gaps matter more than the simple single-parameter 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?

The single 'save' parameter has 100% schema description coverage including its default, and the description's '(with optional save)' aligns with that. Nothing is added beyond the schema, which is acceptable at this coverage level.

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 ('Close the current project'), which is clearly distinct from siblings like save_project, save_project_as, and open_project. The parenthetical clarifies the save option but the scope of 'current project' is left implicit.

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 call this versus save_project/open_project, no preconditions (must a project be open?), and no mention of what happens when save=false. The agent must infer all usage context.

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

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

With no annotations, the description carries the full burden and does not say whether this mutates or deletes media, whether it is reversible, what 'consolidate' does to the surviving copy, or what permissions are needed. For a zero-param operation with an implied destructive effect, this is a meaningful gap.

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

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

A single short sentence with no filler, so it is concise and front-loaded. However, the brevity reflects under-specification rather than tight editing — the one sentence omits everything an agent needs beyond the topic.

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, no annotations, and no scope statement: the description never says which project (active?), what counts as a duplicate, or what the result looks like. For an operation with real media-management consequences, the definition is too thin to call safely.

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

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

The input schema has zero properties, so there is nothing for the description to elaborate on. Baseline 4 applies; no parameter-level information is missing.

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

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

Names a verb ('Consolidate') and a resource ('duplicate media in the project'), so the general domain is identifiable. But 'consolidate' is ambiguous — it could mean merge, deduplicate, relink, or delete — and the description does nothing to distinguish it from siblings like relink_media or delete_project_items.

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

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

No indication of when an agent should reach for this tool versus relink_media, refresh_media, or delete_project_items. There are no preconditions, no exclusions, and no alternatives named despite a large sibling set touching the same 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?

No annotations are provided, so the description must carry the behavioral burden. It does not disclose what happens on duplicate names, whether the bin is created selected/visible, error conditions, permissions, or what the tool returns after creation.

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 efficient sentence with the verb and resource front-loaded. It is appropriately sized, though it could have used the space to add usage or behavioral context.

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

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

For a simple two-parameter creation tool with full schema coverage and no output schema, the description is minimally sufficient. However, with no annotations it leaves mutation behavior and failure modes entirely unexplained.

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 are already documented in the input schema. The description's parenthetical '(folder)' adds a small clarifying synonym for 'bin' but no additional parameter semantics beyond the schema.

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

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

The description states a specific verb ('Create') and resource ('a new bin (folder)') and locates it ('in the project panel'). It is clear enough to distinguish from sibling tools like create_sequence or create_sub_clip, though it does not explicitly contrast with them.

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

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

There is no guidance on when to use this tool versus alternatives such as import_media or create_sub_clip, nor any prerequisites. Usage is only implied by the verb 'Create'.

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 only says "Create proxy media" and does not disclose what happens if proxy media already exists, where proxies are stored, whether the operation overwrites files, or what permissions/processes are involved for this mutation.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple two-parameter tool whose schema already documents the inputs.

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

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

Given that there are no annotations and no output schema, the description is not complete enough for a mutation tool. It omits key operational context such as whether existing proxies are replaced, expected time or side effects, and how success or failure is reported.

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 are already documented in the schema. The description implies the nodeId refers to a project item but adds no meaningful detail beyond what the schema provides, 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?

The description states a specific verb and resource: "Create proxy media for a project item." This is clear enough for an agent to understand the operation, but it does not distinguish the tool from close siblings like attach_proxy or toggle_proxy_mode.

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 attach_proxy or toggle_proxy_mode. The description gives no prerequisites, context, or exclusions for invocation.

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

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

No annotations are provided, so the description carries the full behavioral burden and discloses almost nothing. It does not say whether the new sequence is empty, is added to the project bin, becomes the active sequence, or what permissions/state it requires. Only the word "Create" signals a mutation.

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 single sentence is front-loaded and free of filler, but its brevity comes from under-specification rather than efficiency. Nothing here wastes space, yet nothing earns its place beyond the tool name.

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, no output schema, and several same-family siblings, the description is far too thin. An agent cannot predict the side effects or the return value (e.g., the new sequence's ID) from this text.

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%: both `name` and `presetPath` (including the "omit for default settings" fallback) are documented inline. The description adds nothing beyond the schema, 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?

"Create a new sequence" simply expands the tool name create_sequence with no additional information. It does not distinguish the tool from close siblings such as create_sequence_from_clip, clone_sequence, or import_sequences, so an agent learns nothing it could not infer from the name alone.

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

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

There is no guidance on when to use this versus create_sequence_from_clip (build from an existing clip) or clone_sequence (duplicate). No prerequisites, no mention of what the resulting sequence contains or whether it becomes the active sequence.

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 and largely fails it. It does not say whether the new sequence is added to the project bin, whether it becomes the active sequence, what happens if nodeId points to a non-clip item, or whether a project must be open – all material for a creation/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 tight sentence with the purpose front-loaded and no filler. The trailing "etc." is slightly loose where an enumerated setting list or an omitted count would be sharper, but overall it is well-proportioned.

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 sequence-creating mutation with zero annotations and no output schema, the description omits almost everything an agent needs: where the sequence lands, what happens to existing sequences, what identifiers come back, and how it differs from create_sequence. The basic intent is clear, but the operational context is not.

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

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

Schema coverage is 100% and the nodeId description ("the nodeId of the project item to base the sequence on") already explains the parameter. The description's contribution is only the word "clip," which is not strictly consistent with the schema's broader "project item" wording, adding no real semantics 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 and resource ("Create a new sequence") plus the mechanism (matching a clip's settings, with resolution/frame rate as examples), so an agent knows exactly what it produces. It stops short of a 5 because it never distinguishes itself from close siblings like create_sequence, clone_sequence, or create_subsequence.

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

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

The use case is only implied: you would reach for this when an existing clip already has the settings you want. There is no explicit when-to-use, no exclusion against create_sequence or clone_sequence, and no stated prerequisite that the nodeId must reference a clip/project item.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the basic creation action and that in/out points are used, but it does not explain whether the source project item is modified, what the result is, permissions needed, or any other side effects relevant to a creation operation.

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

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

The description is a single front-loaded sentence with no filler. It is efficient, though its terseness leaves behavioral gaps that a longer description could address.

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 creation tool with five parameters, no annotations, and no output schema, the description is minimally adequate. It identifies the action and key inputs, but does not describe the created object's output or side effects, leaving the agent to infer important behavior.

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

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

Schema description coverage is 100%, so all five parameters already have documented meanings in the schema. The description reinforces the source project item and in/out point parameters but does not add syntax, constraints, or further semantics beyond the schema.

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

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

The description states a specific verb and resource: 'Create a sub-clip from a project item with specific in/out points.' It is clear what the tool does and includes the source and boundary concept, but it does not explicitly distinguish it from sibling tools like create_subsequence or nest_clips.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as create_subsequence, create_sequence_from_clip, or nest_clips. The description only implies usage by saying it creates a sub-clip, without conditions, exclusions, or prerequisites.

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 disclosure burden. It says a subsequence is created but not whether this mutates the project, where the result appears (project panel vs. timeline), whether the source sequence is affected, or what happens when no in/out range is defined — significant gaps for a creation 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?

One short sentence with the scope information front-loaded and no filler. It is efficiently written, though the terseness contributes to the missing prerequisites noted elsewhere.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description is minimally adequate. It omits the key prerequisite (an active sequence with in/out points) and what the created subsequence is, which an agent would need to invoke it correctly.

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

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

There is a single optional parameter and schema description coverage is 100%, so the schema already explains ignoreTrackTargeting fully. The description adds nothing about it, 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?

The description gives a specific verb+resource ("Create a subsequence") plus the source of the range ("in/out range of the active sequence"), which is meaningful scope information. It does not distinguish itself from nearby siblings like create_sub_clip, nest_clips, or clone_sequence, so an agent must infer the difference.

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: it presupposes an active sequence with in/out points already set, but never says so explicitly, nor what to do if no range exists. No alternatives or exclusions are named, leaving the agent to compare against create_sub_clip and nest_clips on its own.

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

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

Since no annotations are provided, the description must convey the high risk associated with this action. While the verb 'Delete' implies destruction, the lack of any warning, irreversibility note, or operational context fails to properly disclose the behavioral risks of this 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 description is perfectly concise, stating the function in a single, direct sentence with no wasted words.

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

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

As a destructive tool with no output schema, the description is incomplete. It lacks any safety context, confirmation steps, or crucial warnings necessary for an agent making a high-impact mutation call.

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

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

Schema coverage is 100%, so the schema already explains that 'nodeIds' is an 'Array of nodeIds to delete.' The description provides no semantic information beyond what is already structurally defined for the single input parameter.

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

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

The tool clearly identifies the action (Delete) and the target resource (project items). However, given the large number of related siblings like 'get_project_items' and 'rename_project_item', it fails to differentiate itself or state what exactly constitutes a 'project item.'

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

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

The description implies usage by stating it deletes items 'from the project panel.' However, it offers no guidance on when *not* to use it, or if there are specific constraints (e.g., item status) that should prevent deletion.

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 behavioral burden, yet it does not say whether deletion is permanent, whether undo can restore it (an undo tool exists among siblings), whether the source media is touched, or what happens if the sequence is currently active. It signals destructiveness only through the verb 'Delete'.

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 short sentence with no filler and the action front-loaded. It is efficient, though brevity here borders on under-specification rather than tight writing.

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

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

The tool is simple (one required ID, no output schema), so the bar is low, but for a destructive operation with zero annotations the description should say at least whether the action is reversible or how to obtain the sequenceId. As written it is adequate but leaves out the details an agent would want before deleting.

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

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

There is a single required parameter with 100% schema description coverage ('The sequence ID to delete'), so the schema fully documents it. The description adds no format hints, ID-source hints (e.g. from get_sequences), or validation notes, making 3 the correct baseline.

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

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

The description names a specific verb (Delete) and resource (a sequence), scoped to the project, so the agent can tell it is not a clip or project-item deletion. It does not explicitly distinguish itself from neighbors like remove_clip, ripple_delete, or delete_project_items, but the resource noun does most of that work.

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 versus delete_project_items, ripple_delete, or remove_clip, and no stated prerequisites (e.g. whether the sequence must be closed or inactive). The agent must infer usage entirely from the name.

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 behavioral burden. It clearly describes the state change, but omits details such as whether it affects all tracks, only the active sequence, or whether the operation is undoable. For a simple zero-parameter action this is adequate but not rich.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately conveys the complete action.

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

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

Given the tool's simplicity, zero parameters, and no output schema, the description is complete enough to invoke it correctly. A minor gap is the lack of clarification about timeline scope, such as active sequence vs all tracks.

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 there are no parameter semantics to explain. The description does not need to compensate for schema gaps, and the baseline for zero-parameter tools applies.

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

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

The description states a specific verb and resource: deselect all clips on the timeline. It is clearly distinct from the sibling select_clips, though it does not explicitly name or contrast with that alternative.

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

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

Usage is implied by the action name: use it when clearing the current timeline selection. However, the description does not explicitly say when to use it instead of select_clips or get_selection, nor does it mention any prerequisites or scope limitations.

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 must carry the full behavioral burden. It only says 'duplicate a clip' and omits whether the source remains unchanged, what happens to existing clips at targetTime, and whether a target track is required or optional.

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

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

The description is a single front-loaded sentence with no wasted words. It states the core action and scope 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?

This is a mutating timeline operation with five parameters and no annotations or output schema. The schema fully covers parameter semantics, but the description is too sparse to explain side effects, overwrite behavior, or placement semantics for a duplication tool.

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

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

Schema description coverage is 100%, so the input schema already documents clipIndex, trackType, trackIndex, targetTime, and targetTrackIndex. The description adds no parameter meaning beyond the schema, which makes the baseline score of 3 appropriate.

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

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

The description states a specific verb and resource: 'Duplicate a clip on the timeline.' It is clear what the tool does, but it does not differentiate itself from nearby siblings such as create_sub_clip, clone_sequence, or move_clip_to_track.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. 'On the timeline' implies the domain, but an agent gets no help deciding between this tool and related clip/sequence creation or move 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?

No annotations are provided, so the description carries the full disclosure burden. It does reveal the key side effect (creates individual audio files, optionally places them on the timeline), but says nothing about where files are written, what happens to existing timeline audio at those positions, whether the operation costs API credits, or what is returned.

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

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

Two short sentences with the core action front-loaded and the side effect second. Nothing is padded, though the second sentence partly duplicates what add_to_timeline and start already state.

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

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

For a 6-parameter generative tool with side effects, no annotations and no output schema, the agent still lacks the return shape (file paths? created clip references?) and any auth or quota constraints. The description covers what the tool does but not enough to predict the result of the call.

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

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

Schema description coverage is 100% and each parameter already documents its type, default and meaning (speed range, model_id default, audio_track index, add_to_timeline default). The description adds only a restatement of the captions-array behavior and the optional timeline placement, which 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?

States a specific verb and resource ('Generate AI voiceover') plus the scope that distinguishes it: multiple caption texts, one audio file each. It implicitly contrasts with the single-utterance sibling elevenlabs_generate_speech but never names it, so the differentiation requires inference.

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 scenario ('for multiple caption texts'), and the timeline placement is framed as optional, which hints at the add_to_timeline decision. There is no explicit when-to-use versus elevenlabs_generate_speech or when-not guidance, and no prerequisites such as needing a voice_id or API key.

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 key traits: it writes a file to disk, may mutate the Premiere project, and requires an ELEVENLABS_API_KEY. It is slightly imprecise about defaults, describing import and timeline placement as one optional step even though they are two independent flags (import_to_premiere defaults true, add_to_timeline defaults false).

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

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

Three short sentences with the core action front-loaded and the environment prerequisite trailing. No filler, though the middle sentence slightly muddles two separate behaviors (import vs. timeline placement).

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 12-parameter tool with no annotations and no output schema, the description omits useful context: where the audio file is saved, whether the call is billed/network-bound, and what the tool returns (path or project item). The schema covers parameter details, but the result contract is left to inference.

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

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

Schema description coverage is 100%, so every parameter including ranges and defaults is already documented in structured data. The description adds only the general notion of optional Premiere import and timeline placement, no new meaning per parameter — 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 ('Generate speech audio from text using ElevenLabs AI') plus the downstream side effect of saving/importing into Premiere. It is clearly distinguishable from elevenlabs_list_voices, but it never names or contrasts with the closest sibling, elevenlabs_generate_captions_voice.

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 'from text' and the timeline-import option, but there is no explicit when-to-use or when-not guidance, and nothing tells the agent when to pick this over elevenlabs_generate_captions_voice or how to chain it after elevenlabs_list_voices.

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 add genuinely useful context by disclosing the ELEVENLABS_API_KEY environment variable requirement, but says nothing about whether the call is read-only, whether it hits a rate limit, or what the voices are keyed by for downstream use.

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 waste, and the core action is front-loaded ahead of the prerequisite. Nothing is padded or repeated from the tool name.

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 tool with no output schema, the description covers what it does and what it needs to run. The one gap is not telling the agent that returned voices supply the voice identifier consumed by the sibling generation tools.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. No misleading parameter claims are made.

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

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

States a specific verb and resource ("List available ElevenLabs voices"), which is unambiguous on its own. It does not explicitly distinguish itself from the two ElevenLabs siblings (generate_speech, generate_captions_voice), though the verb difference makes the distinction reasonably inferable.

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: an agent can infer this is the discovery step before calling elevenlabs_generate_speech or elevenlabs_generate_captions_voice, but neither sibling nor that workflow is named. The API-key prerequisite is the only explicit operational guidance given.

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. Beyond implying a mutation, it does not explain side effects of disabling a clip, whether the change is reversible, permission requirements, error behavior for missing clips, or what the operation 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?

The description is a single front-loaded sentence with no filler. It is concise, though its brevity contributes to the missing behavioral context rather than being a structural flaw in itself.

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

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

This is a four-required-parameter mutation tool with no annotations and no output schema, yet the description says almost nothing beyond the action. It does not describe side effects, state changes, or return behavior, leaving important context for an agent to infer.

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

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

Schema description coverage is 100%, and the schema already explains each parameter, including that enabled true means enable and false means disable. The description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb pair ("Enable or disable") and resource ("a clip on the timeline"), so the basic action is clear. It does not explicitly distinguish this from nearby tools such as set_clip_mute or set_effect_enabled, but the clip-level enable/disable action is still recognizable.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. An agent must infer its place among many clip/timeline sibling tools from the name and schema 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses very little. It does state returns are JSON, but it never warns that this runs arbitrary code with real side effects on a live project, whether it is sandboxed, whether failures are atomic, or whether changes are undoable. For a maximal-power tool, this is a significant gap.

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

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

Three short sentences, front-loaded with the purpose before the usage rule and the return note. No filler and no repetition, though the return sentence is slightly redundant given it is not the main concern here.

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

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

This is an arbitrary-code-execution tool with no annotations and no output schema. The description does not cover error behavior, whether partial writes persist, what scope and permissions the script runs under, or how it relates to execute_qe_script. Too much an agent needs is missing for a tool of this power.

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

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

Schema coverage is 100%, and the schema already tells the caller the script must return a JSON.stringify'd result, so the description adds nothing about the single parameter. With the schema doing all the work, 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?

The definition names a specific verb and resource: execute ExtendScript in Premiere Pro. It positions itself as the general fallback ('operations not covered by other tools'), which distinguishes it from the large sibling set at a category level. However, it never names the obvious sibling alternative, execute_qe_script, so the boundary is only implied.

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

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

The phrase 'Use for operations not covered by other tools' gives an implied when-to-use, but there is no explicit when-not-to-use, no preference ordering, and no mention of execute_qe_script, which is a near-twin in the sibling list. An agent cannot tell from the description which of the two script executors is appropriate.

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

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

With no annotations, the description carries the full behavioral burden. It never says that arbitrary code runs with app-level privileges, whether scripts can mutate project state, what happens on script error, or what gets returned (the schema hints at JSON.stringify but the description is silent). For a code-execution tool this is a significant disclosure gap.

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

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

Two tight sentences, purpose front-loaded, no filler. It is efficient, though the brevity is also the source of the missing safety context.

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 and no annotations, so the description must explain return shape, failure modes, and side effects on its own and does not. For an arbitrary-code-execution tool the definition is under-specified about consequences.

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?

One required parameter with 100% schema coverage; the schema already states the code must use qe.* objects and return a JSON.stringify'd result. The description adds only the framing 'using the QE DOM', which reinforces but does not extend 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?

A specific verb (Execute) plus a named resource (ExtendScript via the QE/Quantum Engine DOM), with a brief statement of why it exists: reaching internal Premiere functions outside the public API. It does not, however, contrast itself with the closely related execute_extendscript sibling, so distinctness must be inferred.

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

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

The phrase 'internal Premiere functions not in the public API' implies when this tool is warranted over the public-API route, but there is no explicit when-to-use/when-not guidance and the obvious alternative (execute_extendscript) is never named. An agent must infer selection criteria from the mention of the QE DOM.

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 and mostly doesn't. It does implicitly signal a dependency on an active sequence (behavioral context worth something), but says nothing about overwrite behavior for an existing file at outputPath, whether the call blocks on a render, what permissions/DiskCache are needed, or whether the sequence is modified.

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

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

A single front-loaded sentence with no filler; the format and source are stated first. It is efficiently sized, though the terseness borders on under-specification for a five-parameter export 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?

Five parameters, no annotations, no output schema, and a mutation-adjacent operation that writes files to disk. The description never covers the return value (success/path), failure modes for an invalid outputPath, or the Pro Tools round-trip caveats implied by "etc." — too thin for the 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 100% and each of the five parameters carries its own description and default (48000 Hz, 16-bit, mixdown/explode false), so the schema does the heavy lifting. The description adds no format constraints or guidance on the optional conversion flags, 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?

Names a specific verb (export), the exact source resource (the active sequence), and the output format (AAF), which is what actually distinguishes it from export_omf/export_edl/export_final_cut_xml. It stops short of an explicit sibling contrast, but the format name does most of the disambiguating work.

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?

"for Pro Tools, etc." implies the intended workflow and hints at the interchange-tool family, but with five sibling exporters (export_sequence, export_omf, export_edl, export_final_cut_xml, export_direct) the description never states when to pick AAF over OMF or when not to use it. Usage must be inferred from the format name alone.

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

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

No annotations are provided, so the description carries the full burden. It says 'Export ... to a file' but never states that it writes to disk, whether an existing file at outputPath is overwritten, whether it requires an open sequence or caption track, or what happens on failure — all material for a file-writing operation.

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

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

A single short sentence, front-loaded with the verb and resource, with zero filler. It is arguably over-trimmed rather than bloated, so it earns high but not top marks on structure.

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

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

The tool is simple (three params, one required) and the schema is fully described, so most of the calling contract is covered elsewhere. Still, with no annotations and no output schema, the agent gets no information about side effects on disk or which sequence/track the export draws from.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema, which sets the baseline at 3. The description adds nothing about outputPath or trackIndex, and its 'SRT, SCC, MCC, etc.' phrasing actually misleads by implying open-ended formats when the enum is a closed set of five.

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 (Export) plus specific resource (captions) and a parenthetical listing output formats, so the agent knows exactly what it produces. It does not distinguish itself from neighbouring exporters (export_sequence, export_aaf) or from import_captions beyond the verb, so a sibling-aware sentence is missing.

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 versus export_sequence or export_direct, no prerequisite such as an active sequence or existing caption track, and no exclusions. The agent must infer usage entirely from the name.

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 key trait: the call is synchronous and blocks Premiere until completion. It says nothing about overwriting an existing output file, behavior on failure, permission requirements, or what is returned, so meaningful gaps remain.

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

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

A single front-loaded sentence with the operation, the target, and the blocking caveat; no filler and nothing redundant.

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

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

The blocking nature and target sequence are covered, which is the core need for a two-parameter export. With no annotations and no output schema, the description should still say whether it overwrites an existing file and what a successful result looks like.

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 real meaning the schema lacks: the exported sequence is the *active* one, so no sequence identifier is expected. It adds nothing about outputPath/presetPath beyond the schema, which already documents both.

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

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

States a specific verb (export/render) and resource (the active sequence), with 'directly' signaling the synchronous variant. It does not name the sibling export_sequence or explain how the two differ, so the agent must infer the distinction from the parenthetical.

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

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

'use for short sequences' is an explicit when-to-use condition, which is better than nothing. However, it never names the alternative tool (export_sequence) or states the when-not case for long sequences, leaving the agent to guess which export path to choose.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It says what is exported but omits whether the output file is overwritten, what permissions are required, how errors are reported, or whether the tool modifies project state. For a file-writing mutation tool, this is a significant transparency gap.

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

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

The single sentence is front-loaded and contains no filler. It is efficient, though its brevity contributes to the missing behavioral context.

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

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

For a simple export tool with no annotations and no output schema, the description covers the core action but leaves important context unstated: overwrite behavior, error handling, and how it differs from other export siblings. It is 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 description coverage is 100%, so both parameters (outputPath, trackIndex) are fully documented in the schema. The description adds no additional parameter semantics, which is acceptable given complete schema coverage.

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

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

The description states a specific verb ('Export') and resource ('active sequence as an EDL file'), making the operation clear. However, it does not differentiate itself from the many sibling export tools (export_sequence, export_aaf, export_omf, export_final_cut_xml) beyond mentioning the EDL format, so an agent must infer the differences from the format name alone.

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

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

There is no guidance on when to use this tool versus alternatives like export_sequence or export_aaf. The only implicit cue is 'active sequence,' but no exclusions or preconditions are given.

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 and largely drops it. It says nothing about whether the exported file overwrites an existing file at outputPath, whether permissions or an active sequence are required, whether the operation is non-destructive, or what is returned on success/failure.

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

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

One short, front-loaded sentence with zero filler. It is appropriately sized for a one-parameter export, though it could have spent a few extra words on disambiguation from the other export siblings at no real cost.

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

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

For a simple one-parameter export with full schema coverage and no output schema, the essentials are present. However, it omits the return behavior and file-overwrite semantics that an agent needs to call it safely, which is noticeable given there are no annotations to compensate.

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

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

Schema description coverage is 100% and the single parameter includes a clear description ('Full output file path (.xml)'), so the schema does the heavy lifting. The description adds no further meaning about path conventions, overwrite behavior, or extension handling, so the baseline 3 applies.

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

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

States a specific verb ('Export'), a specific source object ('the active sequence'), and the target format ('Final Cut Pro XML'). It is distinguishable from siblings like export_aaf or export_edl only by the named format, not by any explicit contrast, so it falls short of a 5.

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

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

There is no guidance on when to choose this over export_sequence, export_aaf, export_omf, export_edl, or export_direct, all of which sit in the same sibling cluster. The only implied condition is that an active sequence must exist, which the agent must infer from the phrase 'the active sequence'.

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, yet it says nothing about what is written to disk, whether an existing file is overwritten, where the frame is sourced from, or what happens on failure. 'Export ... as an image' plus a required outputPath only hints at a file write.

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 short sentence, front-loaded with the verb and resource, with no wasted clauses. The trailing 'etc.' is mildly loose given the format enum is fixed, but overall it is tight and readable.

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 should clarify the frame source (active sequence vs source monitor), overwrite behavior, and success signal. None of that is present, leaving real ambiguity for a file-writing 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 100%, so all three parameters (time, format, outputPath) are documented in the schema, including the enum of formats and the default of png. The description adds no semantics beyond that, which is acceptable at this coverage level.

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 ('Export a single frame as an image') and the 'single frame' scoping distinguishes it from sequence-level siblings like export_sequence and render_sequence_preview. It never names an alternative explicitly, but the resource scope is unambiguous.

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

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

Usage is only implied by the word 'frame' versus siblings that handle whole sequences. There is no explicit statement of when to choose this over export_sequence, render_sequence_preview, or freeze_frame, and no mention of prerequisites such as an active sequence or playhead.

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 and does not meet it. It doesn't disclose whether export is synchronous and slow, whether media is embedded or referenced, whether audio-only content is exported, what happens if no active sequence exists, or where the result goes beyond the outputPath parameter.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity contributes to gaps scored elsewhere rather than earning a top mark here.

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, and the description says nothing about return values, side effects, or failure conditions for a file-writing operation. Parameter documentation is fully covered by the schema, but the behavioral picture remains incomplete.

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

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

Schema description coverage is 100%, so all four parameters (outputPath, sampleRate, bitsPerSample, handleDuration) are already documented with defaults in the schema. The description adds no additional meaning about parameter interaction, so the baseline 3 applies.

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

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

States a specific verb and resource ("Export ... as an OMF file") and clarifies the implicit scope by naming "the active sequence", so the agent knows no sequence ID is needed. However, it does nothing to separate itself from close siblings like export_aaf or export_sequence, which an agent must choose between.

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

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

There is no guidance on when to choose OMF over export_aaf, export_edl, export_final_cut_xml or export_sequence, and no prerequisites such as requiring an active sequence. The agent must infer the choice entirely from the format name.

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, yet it only alludes to the AME dependency. It doesn't say whether the call blocks until rendering finishes, returns a job handle, overwrites an existing file at outputPath, or what happens if AME is unavailable – all critical for a long-running export operation.

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

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

A single front-loaded sentence with zero filler, but it is arguably too terse for a five-parameter export operation – conciseness is good, completeness is not.

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/export tool with no annotations and no output schema, the description should at least explain the return value (job, file, or path), whether the call is synchronous, and the AME dependency semantics. None of that is present, leaving significant gaps for an agent invoking it.

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

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

Schema description coverage is 100%, so all five parameters (outputPath, presetPath, startTime, endTime, useInOut) are already documented in the schema, and the description adds nothing beyond them. Baseline 3 is appropriate given 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 verb ('Export/render'), a specific resource ('the active sequence'), and the rendering engine ('Adobe Media Encoder'), so an agent knows exactly what operation is performed. It does not differentiate itself from sibling export tools such as export_direct, render_sequence_preview, or the XML/AAF/EDL exporters, which an agent must infer on its own.

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

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

There is no explicit guidance on when to use this tool versus export_direct, render_sequence_preview, or the other export_* siblings, and no mention of prerequisites such as AME being installed/running or presets coming from get_encoder_presets. Usage is only implied by the phrase 'active sequence'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure and largely drops it. It does not say whether the operation is read-only (implied by "search" but unstated), whether all matches or a capped page are returned, or how matching and case sensitivity behave.

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

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

A single front-loaded sentence with no filler, and the core action leads. It is efficient but so terse that the brevity comes at the cost of the usage and matching details 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 two-parameter search tool with no output schema and no annotations, the description should at minimum state the match semantics, the return shape (all matches vs. truncated), and the relationship to the adjacent list/get tools. None of that is present, leaving the agent to guess on the exact parts that determine correct invocation.

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

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

Schema description coverage is 100%, so both `query` and the `type` enum are already documented, and the baseline is 3. The description's only addition is the word "pattern," which actually introduces ambiguity about match semantics rather than resolving it, and the type filter goes unmentioned.

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 ("Search project items") with the matching dimension named ("by name pattern"), so an agent knows it is a filtered lookup rather than a mutation. It fails to differentiate from the sibling get_project_items, which lists items, or from get_project_item_info, which fetches one item's details.

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

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

No guidance on when to use this instead of get_project_items (list all) or get_project_item_info (single item by ID), which is the main routing decision an agent faces in this family. It also never states what "pattern" means — substring, wildcard, regex, case sensitivity — so the agent cannot reliably construct a query.

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 bears the full disclosure burden. It conveys the user-visible motive (disk space, cache corruption) but says nothing about irreversibility, whether the project must be idle, or whether media must be re-conformed/re-rendered afterward — relevant for a deletion-style operation.

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

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

One sentence, action first, rationale second in parentheses. Nothing redundant and nothing that could be trimmed without losing meaning.

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

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

For a zero-param, no-output tool this is nearly sufficient, but with zero annotations the description is the only source of behavioral information and omits post-condition effects (cache rebuilt on next playback, any disruption to open projects). Adequate, 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the empty schema is self-explanatory. Baseline 4 applies for a param-less tool.

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

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

Names a specific verb+resource combination ("Flush the media cache") that an agent can map directly to an action. No sibling tool in the list touches cache state, so there is no ambiguity to resolve against alternatives.

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

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

Explicitly states the two situations that call for this tool: freeing disk space and resolving cache issues. It stops short of when-not-to-use guidance or any prerequisite (e.g. save project first), which is why it is not a 5.

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

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

No annotations are provided, so the description carries the full behavioral burden. It indicates a mutation ('apply') but does not explain whether the freeze frame extends clip duration, affects linked audio, is reversible, or what happens to existing clip content after the freeze point.

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

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

The description is a single front-loaded sentence with no wasted words. It communicates the core action and location efficiently.

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

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

For a mutation tool with no annotations and no output schema, the definition is incomplete. It does not cover behavioral effects on the timeline, required permissions or selection state, or what the tool 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 all five parameters are already documented in the schema. The description reinforces that the freeze applies at a specific point in a clip, but adds no parameter-level detail beyond what the schema provides.

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

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

The description states a specific verb and resource: apply a freeze frame at a specific point in a clip. It is clear what the tool does, though it does not explicitly differentiate itself from nearby timeline-editing siblings such as razor_clip or add_adjustment_layer.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites such as clip selection or applicable track types. Usage is only implied by the phrase 'at a specific point in a clip'.

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 burden. It does disclose the shape of what comes back (tracks, position, settings), but does not say what happens when no sequence is active, whether it errors, or that it is a non-mutating read.

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

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

A single front-loaded sentence with zero filler. The scoping qualifier ('currently active') and the returned-content list are both immediately visible.

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 is the only source of information about return content, and it partially covers that with the tracks/position/settings list. It stops short of explaining failure modes (no active sequence) or how the payload relates to the sibling get_sequence_settings.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The parenthetical field list adds minor value by previewing what the call returns.

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

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

States a specific verb and resource ('Get detailed info about the currently active sequence') and scopes it to the *active* sequence, which implicitly separates it from the sibling get_sequences (list all). It does not explicitly name a sibling to distinguish itself, so it falls short of a 5.

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

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

Usage is only implied: the phrase 'currently active' hints that this is called after set_active_sequence to inspect the open sequence. No explicit when-to-use, when-not-to-use, or alternative (get_sequences, get_sequence_settings, get_timeline_clips) is mentioned.

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

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

With no annotations, the description carries the full burden. 'Get' implies a harmless read and 'build info' adds a useful hint about return content, but there's no statement about permissions, environment requirements, or failure behavior when Premiere Pro isn't running.

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

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

A single front-loaded sentence with no filler. Every word earns its place.

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

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

For a zero-parameter read with no output schema, the description does enough by naming the two return items (version and build info). A note on behavior when Premiere Pro is unavailable would close the remaining gap.

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