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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explain whether existing keyframes are overwritten or appended, what constraints apply to audio levels, or what happens if the clip is not an audio clip. The description is minimally informative but not misleading.

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, concise sentence that communicates the core purpose without unnecessary words. It is appropriately sized for a simple tool, though it could include a bit more behavioral context without becoming bloated.

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

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

The tool has a simple schema with fully documented parameters, but there are no annotations and no output schema. The description does not cover when to use this tool, how it interacts with existing keyframes, or any prerequisites, leaving an agent with gaps in deciding whether and how 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?

The input schema provides full coverage for both parameters, including time in seconds and audio level in dB. The description adds slight value by framing the keyframes as enabling 'dynamic volume changes,' but it does not add meaning beyond the schema's descriptions.

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

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

The description clearly states the tool's action: adding keyframes to audio levels for dynamic volume changes. It identifies the verb ('adds'), the resource ('audio levels'), and the purpose ('dynamic volume changes'), making it distinguishable from generic keyframe tools like add_keyframe, though it doesn't explicitly name any sibling.

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

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

No guidance is provided about when to use this tool versus alternatives such as add_keyframe, set_clip_volume, or adjust_audio_levels. The description only states what the tool does, not the conditions that make it the right choice.

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 only says 'add,' implying a mutation, but gives no information about side effects, persistence, reversibility, permissions, or what happens if the field already exists.

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 short but under-specified. The phrase 'Premiere Pro expanded operation' adds no useful meaning, and the rest simply repeats the tool name. This is under-specification rather than effective 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?

With no annotations, no output schema, an open-ended input schema, and a one-line near-tautology, the description is completely inadequate for an agent to understand what inputs to provide or what the tool will do. It does not even clarify what a 'custom metadata field' refers to in Premiere Pro.

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 declares zero named parameters, so the baseline is 4. The description adds no parameter details, but there are no schema parameters for it to clarify either.

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 'add custom metadata field' is essentially a word-for-word restatement of the tool name, preceded by the boilerplate 'Premiere Pro expanded operation.' It reveals the general action but does not clarify what a 'custom metadata field' is, where it is added, or how it differs from metadata-related siblings like set_xmp_metadata or attach_custom_property.

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

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

There is no guidance about when to use this tool versus alternatives. The description offers no context, prerequisites, or exclusions, and the large sibling list includes closely related metadata tools without any differentiation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state what happens if a keyframe already exists at the given time, whether keyframes are inserted or overwritten, or what side effects occur in the timeline. The behavior is described only at the most basic action level.

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

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

The description is a single clear sentence with no filler or redundancy. The core action and target are front-loaded, making it easy for an agent to parse quickly.

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 mutation tool with fully documented required parameters, the description is minimally adequate. However, the absence of annotations, output schema, and behavioral details such as duplicate-timestamp handling leaves notable gaps for an agent that needs to reason about edge cases.

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

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

Schema description coverage is 100%, and each parameter already includes meaningful descriptions such as 'display name of the parameter' and 'The ID of the clip.' The tool description adds no additional semantic context beyond the schema, 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 clearly states a specific verb ('adds'), a resource ('keyframe to a clip component parameter'), and a temporal qualifier ('at a specific time'). This distinguishes it well from sibling tools like remove_keyframe, get_keyframes, and 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?

The intended use is implied by the verb 'adds,' but there is no explicit guidance on when to choose this tool over related alternatives such as remove_keyframe or get_value_at_time. No exclusions or alternative mentions are provided.

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?

There are no annotations, so the description carries the behavioral disclosure burden. It transparently communicates that this is a mutating operation and adds the useful non-active-sequence nuance. However, it does not mention return behavior, idempotency, or what happens to existing markers at the same time.

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

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

Two sentences with no filler. The main action is front-loaded, and the important non-active-sequence exception is stated in a short second sentence. Every word earns its place.

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

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

For a straightforward additive operation with a fully described schema, the description is adequate. The main gap is the absence of return-value or error information, but the tool's purpose and parameters are clear enough for an agent 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?

Schema description coverage is 100%, so the input schema already documents all six parameters. The description adds general purpose context but no parameter-level detail beyond what the schema provides, which matches the baseline for full 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 clearly states the action ('Adds a marker') and the target resource ('the specified sequence'), with a purpose ('for navigation or notes'). It also distinguishes itself from active-sequence-only operations by noting the sequence does not have to be active, which separates it from many sibling timeline tools.

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

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

The description provides clear usage context: markers are for navigation or notes, and the tool works on non-active sequences. It does not explicitly name alternatives like update_marker or place_markers, so it stops short of full alternative-routing guidance.

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

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

With no annotations, the description must carry behavioral disclosure. It mentions the MOGRT requirement and the mapping of text fields, but does not reveal side effects such as importing a project item, potential failures, or what happens when the track or sequence is invalid. It lacks clarity on the operational impact beyond adding a layer.

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 concise: two sentences that front-load the main purpose and then provide essential detail. Every clause contributes, and it avoids repetition of schema information. It is well-structured and easy to parse.

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 has 11 parameters, many of which have nuanced behavior (e.g., textPropertyName override, rollbackOnTextFailure), the description does not cover error cases, success criteria, or operational prerequisites beyond what the schema already states. It does not explain when to use the override or rollback parameters, nor the consequences of missing track or MOGRT. The absence of an output schema further increases the need for such 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 coverage is 100%, so the baseline is 3. The description adds value by explaining the mapping of text fields to AE components with a concrete example (e.g., Basic Lower Third) and stating 'Supports up to 4 text fields', which is not explicitly in the schema. This goes slightly beyond the schema's individual parameter descriptions.

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

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

The description clearly states the tool's purpose: 'Adds a text layer (title) over the video timeline.' It also specifies the resource (MOGRT template) and the capability of up to 4 text fields. However, it does not explicitly distinguish itself from sibling tools like 'apply_effect' or 'add_to_timeline', so it's not 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 gives no guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites beyond mentioning that a MOGRT path is required. It implies usage for text overlays but does not explicitly state when not to use it or direct users to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the basic action. It does not mention whether rendering starts automatically, whether the queue persists, what happens with overwrite/removeOnCompletion, or that this is an asynchronous mutation of the render queue.

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, direct sentence with no filler, and the action is front-loaded. It is concise, though for a tool with eight parameters and no annotations it is also quite sparse, so it does not earn a 5.

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

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

For a mutating, queue-manipulating operation with no output schema and no annotations, this description is incomplete. It does not explain what happens after the sequence is added, how to monitor the queue via get_render_queue_status, or how startImmediately and removeOnCompletion affect behavior, leaving an agent to infer crucial workflow 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 the schema already documents all eight parameters clearly. The description itself adds no parameter-level meaning beyond the schema, so the baseline score 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 ('Adds') and a clear resource ('sequence to the Adobe Media Encoder render queue'), so an agent can tell it involves queueing for AME. However, it does not explicitly distinguish it from related sibling tools like start_batch_encode, encode_project_item, or export_sequence, so it stops short of full differentiation.

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 such as start_batch_encode, encode_project_item, or export_sequence. Nothing in the text indicates prerequisites, follow-up steps, or conditions that would make this the preferred choice.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the basic operation and does not mention mutation side effects, insert/overwrite behavior, audio-linking effects, reversibility, or whether existing timeline content can be displaced. The schema documents some parameter-level behavior, but the tool description itself remains 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?

The description is a single, front-loaded sentence with no fluff or repetition. It is concise, but it is also quite sparse for a tool with eight parameters and significant behavioral nuance, so it earns high but not maximum marks.

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 complex, mutation-oriented tool with no annotations, no output schema, and several closely related siblings, the description is not complete enough. It omits mode selection, audio-linking consequences, relationship to batch/source-monitor alternatives, and expected results, so an agent would have to infer critical context from parameter docs and naming.

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 all eight parameters, including defaults and dependencies for source in/out points. The tool description adds no meaningful parameter semantics beyond restating that a clip goes to a track and time, leaving the schema to carry the explanatory load.

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

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

The description states a specific action ('Adds'), a resource ('media clip from the project panel'), and a destination ('to a sequence timeline at a specific track and time'). It is clear enough to distinguish from source-monitor-oriented siblings like insert_from_source and overwrite_from_source, though it does not explicitly differentiate itself from add_to_timeline_batch.

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 versus alternatives such as add_to_timeline_batch, insert_from_source, or overwrite_clip. No context is given about prerequisites, preferred use cases, or excluded scenarios.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses overwrite mode, per-clip result handling, that one failure does not sink the batch, and the exact aggregate status semantics ('success' | 'partial' | 'failure') with placed/failed/total counts. This goes well beyond the schema.

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

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

The description is dense but every sentence earns its place: purpose, speed rationale, equivalence to the sibling, per-clip parameter support, and result semantics. It is organized and front-loaded, with no filler.

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

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

For a batch mutation tool with no annotations and no output schema, the description is remarkably complete. It covers required inputs, overwrite behavior, per-clip failure isolation, return shape, and aggregate status semantics, so an agent has enough to invoke it correctly without external assumptions.

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

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

The schema already documents both parameters and all nested clip properties in detail (100% coverage). The description adds mild reinforcement about per-clip linkAudio and sourceInPoint/sourceOutPoint and calls them Source-monitor in/out, but it mostly restates what the schema already covers, so the baseline 3 applies.

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

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

The description opens with a specific verb+resource ('places MANY clips onto one sequence') and immediately distinguishes itself from add_to_timeline by framing this as the fast batch path. It tells the agent exactly what the tool does and how it differs from the closest sibling.

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 explicitly names add_to_timeline as the single-clip equivalent and frames the batch as the fast path for rebuilding whole edits, which gives clear context for when to choose it. It does not explicitly state 'do not use for a single clip,' but that is strongly implied by the design.

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 disclosure. It only says 'expanded operation' and gives no information about side effects, whether it mutates the timeline, whether an active sequence is required, or what 'expanded' means.

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 short, but brevity here is under-specification rather than efficient conciseness. The single sentence provides almost no actionable information.

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

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

With no annotations, no output schema, and an empty permissive input schema, the description should explain what the tool does, how it behaves, and what an agent needs to know before calling it. It does none of this.

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 defines zero properties but allows arbitrary additional properties, so an agent cannot infer valid parameters. The description adds no parameter information and does not clarify whether arguments are expected or what they might be.

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 'Premiere Pro expanded operation: add tracks' essentially restates the tool name without specifying what 'tracks' means (audio, video, timeline tracks?) or what the operation actually accomplishes. It does not distinguish this tool from siblings like add_to_timeline or add_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 alternatives such as add_to_timeline, add_marker, or add_audio_keyframes. No prerequisites, conditions, or exclusions are provided.

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, but it only restates that volume is adjusted. It does not reveal whether the change is absolute or relative, whether it is undoable, or whether existing keyframes or gain automation are affected, which is significant for a mutating operation.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It is immediately scannable and every word contributes to the core 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 simple two-parameter setter, the description plus schema provides enough to construct a correct call. However, without annotations, an output schema, or any usage/behavioral guidance, it is only minimally complete and leaves the sibling-selection problem unresolved.

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 already documents both parameters completely, including that level is in decibels and can be positive or negative, so schema coverage is 100%. The description adds no parameter-level detail beyond the schema, but since the schema fully covers semantics, baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Adjusts') on a specific resource ('volume (gain) of an audio clip on the timeline'), so an agent can understand the core purpose. It does not, however, differentiate it from the closely-named sibling tool set_clip_volume, which likely targets the same property, so it does not earn 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 gives no guidance on when to use this tool instead of set_clip_volume, mute_track, setup_ducking, or add_audio_keyframes. There are no explicit use cases, prerequisites, or exclusions, leaving the agent to choose among several volume-related sibling tools without additional 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 provided, the description carries the full burden of behavioral disclosure. 'Applies an audio effect' implies mutation but does not state whether the effect replaces existing effects, is additive, requires specific track state, or has any side effects. The agent is left without safety or reversibility context.

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

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

The description is a single clear sentence with no filler. It is appropriately short for a simple tool, though it sacrifices some helpful context for brevity.

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

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

For a tool with no annotations and no output schema, the description is too thin. It does not mention how to discover valid effect names, whether the parameters object is required, or how this relates to the many effect-related sibling tools. The schema covers parameter names but not usage 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 the schema already documents all three parameters including an example effect name. The description adds no additional parameter semantics, so the baseline score 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 the specific action—applies an audio effect—and the target resource, a clip. The word 'audio' differentiates it from the generic 'apply_effect' sibling, though it does not explicitly describe how it differs from batch_apply_effect or apply_audio_effect_to_all_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?

No guidance is given about when to use this tool instead of related tools such as apply_effect, batch_apply_effect, or apply_audio_effect_to_all_clips. There is no mention of prerequisites, such as the clip being an audio clip or selecting an effect name from list_available_audio_effects.

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 disclosure burden. It usefully discloses the execution model ('one ExtendScript call') and that it returns per-clip results. However, it does not mention whether the effect replaces or augments existing effects, undo behavior, or failure handling, leaving some behavioral gaps.

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

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

Three short, information-dense sentences with no filler. The 'Bulk:' prefix front-loads the key differentiator, and each sentence adds value: scope, return shape, and efficiency rationale.

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 combination of the description and 100% schema coverage gives an agent enough to select and invoke the tool: target sequence, effect name, optional parameters, and return granularity. Since there is no output schema, 'Returns per-clip results' is somewhat minimal but adequate for a bulk operation; missing error/undo details would be nice but are not essential.

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 already covers all three parameters at 100% coverage, so the description is not required to repeat them. It adds useful context like 'single audio effect' and 'all clips,' but it does not add significant meaning beyond the schema's parameter descriptions.

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

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

The first sentence states a specific verb and resource: 'applies a single audio effect to ALL audio clips of a sequence.' The 'Bulk:' prefix and 'Saves N MCP roundtrips' clearly distinguish it from per-clip tools like apply_audio_effect. This is unambiguous.

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

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

The 'Bulk:' prefix and 'when calibrating or applying same chain' give clear contextual guidance on when this tool is appropriate. It doesn't explicitly name an alternative tool or state when not to use it, but the roundtrip-saving rationale strongly implies the intended use case.

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

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

With no annotations provided, the description carries the full burden. It openly discloses destructiveness, backup creation, abort behavior without backup, the allowNoBackup escape hatch, CEP helper dependency, and result content including log and activeSequence. No relevant behavioral aspect is left unspecified.

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 long but every sentence adds value — it front-loads the destructive warning and core action, then organizes details logically (backup, abort, marker scope, requirements, side effects, result). While it could be tightened, the length is justified by the complexity of a destructive operation with multiple failure modes.

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?

Despite having no output schema, the description fully explains the return values (log array, activeSequence object) and even advises checking the backup line in the log. It covers all necessary operational context: prerequisites, failure modes, side effects, and user consent. Nothing an agent needs to call this correctly is missing.

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

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

The schema already describes both parameters (mode enum and allowNoBackup with defaults), but the description adds critical context: the abort behavior when backup cannot be confirmed, the explicit condition for passing allowNoBackup, and the meaning of each mode in operational terms. This goes well beyond the schema's basic descriptions.

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

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

The description clearly states the tool applies Lift or Extract to marker ranges with a specific prefix, and distinguishes itself from sibling selection-based tools (lift_selection, extract_selection) by operating on markers rather than selections. The verb and resource are specific and 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?

Provides explicit usage conditions: only acts on markers starting with 'Scout/Cleanup:', tells users to rename markers in other namespaces via remove_markers/place_markers, requires confirmation before invoking, and notes the CEP helper requirement. Clearly differentiates when to use this tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It goes beyond a bare mutation statement by revealing that after applying the effect, the tool identifies the newly created component and verifies parameter readbacks. This gives the agent a sense of the post-conditions and return behavior, though it does not cover failure modes or error handling.

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

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

The description is a single sentence that front-loads the main action and packs additional behavioral details without fluff. It is concise, clear, and every clause adds meaningful information. No redundancy or unnecessary 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?

For a tool with no output schema, the description partially addresses the return value by stating it 'identifies the exact newly created component,' suggesting a returned handle or ID. It also hints at verification of parameter readbacks. However, it does not specify the exact return format or error behavior, leaving some ambiguity for agent usage. Given the moderate complexity, this is nearly complete but not fully.

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 already provides complete descriptions for all three properties (clipId, effectName, parameters), so schema coverage is 100%. The description adds little beyond the schema; it mentions parameter verification but does not elaborate on how the parameters object is structured or used. Given full schema coverage, the baseline 3 is appropriate.

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

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

The description clearly states a specific action ('Applies a visual or audio effect to a clip') with the target resource (the clip). It also adds distinct behavioral details ('identifies the exact newly created component, and verifies parameter readbacks') that set expectations and differentiate it from sibling tools like apply_audio_effect (audio-only) or batch_apply_effect (multiple 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?

The description provides no explicit guidance on when to use this tool versus alternatives such as batch_apply_effect or apply_audio_effect. There is no mention of conditions, exclusions, or scenarios where a different tool is preferred. Usage is only implied by the generic action described, leaving the agent to infer context from the sibling list.

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

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

No annotations are present, so the description carries the full burden. It only states the core action and does not disclose whether the LUT application is reversible, whether it replaces an existing grade, or what side effects it has on the clip.

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 no wasted words. It earns its place without redundancy.

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

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

For a simple 3-parameter tool, the schema fills in the parameters, but the description lacks behavior context and alternative routing. It is minimally viable yet leaves the agent to infer side effects and when this is the right tool among many color-related siblings.

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 each parameter already has a description; the tool description adds 'color grading' context but no parameter-specific meaning 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 and resource: 'Applies a Look-Up Table (LUT) to a clip' and names the intent 'for color grading.' It is clear but does not differentiate from siblings like apply_effect, color_correct, or set_color_value.

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

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

The phrase 'for color grading' implies the domain in which this tool is used, but the description does not say when to choose apply_lut over the many color/effect siblings or mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says the tool 'builds' a timeline but does not state whether it creates a new sequence, overwrites an existing one, modifies the active timeline, or what output it returns. For a potentially mutating assembly operation, this omission is significant.

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

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

Two sentences with no filler. The first sentence states the primary purpose, and the second immediately communicates the two modes of operation. Every clause earns its place, and the most important information is front-loaded.

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

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

The schema is rich and fully covers parameter semantics, but this is a complex mutation-like tool with no annotations and no output schema. The description does not disclose side effects, return value, or how it relates to similar assembly tools, leaving an agent without full context for safe and 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?

The schema already documents all 8 parameters and their roles, so the baseline is 3. The description adds value by framing the parameter relationship: template defaults versus an explicit clipPlan for 'LLM-directed pacing, transitions, motion, trims, and per-clip effects.' This higher-level semantic helps an agent understand how the parameters interlock.

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

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

Starts with a specific verb+resource: 'Builds a production-oriented promo timeline from real media assets.' This clearly differentiates it from siblings like build_brand_spot_from_mogrt_and_assets by emphasizing real media assets and production-oriented assembly. It also introduces the template-defaults vs. explicit-clipPlan distinction, making the tool's core function unambiguous.

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

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

The description gives clear context for when to use the tool: when building a promo timeline from real media assets, either with template defaults or an explicit clipPlan. It does not explicitly name alternatives or state when not to use it, but the context is specific enough for an agent to route toward this tool for this kind of assembly task.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention side effects, requirements, reversibility, permissions, or what constitutes success. A single vague sentence is completely inadequate.

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 short, but brevity is not value. It contains no concrete, actionable information, so it reads as under-specified rather than concisely effective. It does not earn 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 tool that presumably attaches a custom property (likely requiring property name and value) with no output schema, the description is severely incomplete. An agent has no idea what the tool does, what inputs it expects, or what the result would be.

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 defines zero named parameters (though it allows arbitrary additional properties), so the description must explain what properties an agent should supply. It does not, leaving the caller entirely in the dark about required arguments like the property name and value.

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 verb ('attach') and a resource ('custom property'), but 'custom property' is undefined and the target of the attachment is unclear. It does not distinguish this tool from siblings like add_custom_metadata_field or set_xmp_metadata, and the phrase 'Premiere Pro expanded operation' is generic filler.

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 indication of when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. The description provides zero guidance on the context in which an agent should invoke it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'AI-powered motion tracking' but does not state whether the operation modifies the original sequence or creates a new one, whether it is reversible, how long it may take, or what the result/return value is. This is a significant transparency gap for a potentially state-changing 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 12-word sentence with no filler, redundancies, or irrelevant details. The core action and differentiator are front-loaded, making it easy for an agent to parse quickly. It is appropriately sized for the tool's moderate complexity.

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

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

There is no output schema and no annotations, so the description must compensate. It fails to explain what 'reframes' actually does (in-place vs. copy), the role of the optional newName parameter, whether motionPreset affects processing behavior beyond its enum values, or what the tool returns on success/failure. An agent invoking this tool would still have unanswered questions about the operation's outcome and side effects.

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 fully documents all five parameters. The description adds no parameter-level detail beyond restating the aspect ratio concept expressed in numerator/denominator, which is already in the schema. Baseline 3 applies because the schema does the heavy lifting; the description adds no extra meaning.

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

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

The description clearly states the specific action ('reframes a sequence'), the resource ('sequence'), and the target ('a new aspect ratio') while adding the differentiator 'using AI-powered motion tracking.' None of the many sibling tools appear to offer this capability, so the purpose is unambiguous and distinguishes it from the rest.

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

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

The description implies when to use the tool (when a sequence needs automatic reframing to a different aspect ratio), but it does not provide explicit when-not-to-use conditions, prerequisites, or alternative tool guidance. Because no sibling tool performs reframing, the lack of named alternatives is reasonable, yet the description still leaves usage context to inference rather than stating it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals nothing about side effects, whether the operation mutates state, prerequisites (a selected sequence, active clips), or failure modes. A batch mutation tool with zero behavioral disclosure is a material 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?

One sentence long, but this is under-specification, not conciseness. The clause 'expanded operation' is filler noise that earns no credit. There is no functional information being conveyed 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?

A complex batch operation with no annotations, no documented parameters, and no output schema relies entirely on the description — which says nothing useful. The entire calling contract (inputs, effect targets, return values) is absent, so an agent must 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?

The input schema is an empty object with additionalProperties: true, so no parameters are actually documented despite 100% reported coverage. The description adds zero parameter information. Despite the nominal '0 params' baseline, the tool name implies it needs inputs (which effect, which target clips) that are left entirely unspecified, so an agent cannot construct a call.

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

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

The description 'Premiere Pro expanded operation: batch apply effect' mostly restates the name batch_apply_effect. The phrase 'expanded operation' is meaningless boilerplate that adds no signal. It never says what a batch applies an effect across (clips? timeline? tracks?), and it fails to distinguish from sibling apply_effect.

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

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

No guidance whatsoever on when to use this tool versus the dozens of siblings (apply_effect, apply_audio_effect_to_all_clips, set_effect_property, copy_effects_between_clips). No exclusions, no prerequisites, no context for choosing it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to state whether the operation enables, disables, or toggles items; whether it requires a selection; what scope it affects; or whether it changes state destructively. 'Batch enable disable' only names the action class without disclosing any behavior.

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

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

The description is short, but this is under-specification rather than effective conciseness. It provides no structured, front-loaded information about scope, selection, or behavior, and every sentence earns little value.

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

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

With no annotations, no output schema, and a vague one-line description, the tool is severely under-specified. Given the large sibling set with overlapping concepts such as enable_disable_clip and enable_all_clips, an agent cannot determine what the batch operation affects, how the batch is determined, or what result to expect.

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

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

The tool declares zero parameters, so there is little parameter detail the description must supply. However, the schema has additionalProperties: true, meaning arbitrary inputs could be passed, and the description does not clarify whether any are expected; this is a minor gap against the zero-parameter 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 essentially restates the tool name as 'batch enable disable' and adds only the boilerplate 'Premiere Pro expanded operation.' It never identifies the resource being enabled/disabled (clips? tracks? effects?), so an agent cannot tell what the tool operates on. This is close to a tautology and fails to distinguish it from the many sibling tools that also deal with enabling/disabling.

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

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

There is no guidance on when to use this tool versus siblings like enable_disable_clip, enable_all_clips, or select_disabled_clips. The word 'batch' weakly implies a multi-item use case, but no explicit when-to-use or when-not-to-use information is provided.

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, but it only restates the operation. It does not explain what 'expanded' means, whether names require a pattern, whether the operation is reversible, or what side effects occur.

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 short and easy to read, but the opening 'Premiere Pro expanded operation:' is filler that delays the actual action. It is concise but not optimally front-loaded or information-dense.

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

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

For a mutating batch operation with no annotations and no output schema, this description is too thin. It leaves out selection scope, naming rules, failure modes, and what an agent should check 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?

The input schema declares no parameters, so the baseline is 4. The description adds no parameter details, but with zero declared parameters there is little to document; however, additionalProperties: true leaves ambiguity about whether hidden inputs are expected.

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 'batch rename clips' names a clear operation on a clear resource, and the word 'batch' distinguishes it from the singular sibling 'rename_clip'. However, the prefixed phrase 'Premiere Pro expanded operation' is vague and adds no specific meaning.

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

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

No guidance is given about when to use this tool versus alternatives such as 'rename_clip' or 'rename_project_item'. The description also does not state whether it operates on selected clips, project items, or timeline clips.

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

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

With no annotations provided, the description carries the full burden. It discloses high-level behavior: building from real assets, optional MOGRT overlay, clipPlan-driven assembly, and optional default polish. However, it omits side effects, whether a new sequence is created or an existing one is modified, and any prerequisites such as project context.

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

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

The description is two sentences with no filler, and the core action is front-loaded. It is appropriately concise, especially given that the input schema already carries detailed parameter documentation.

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 build operation with no annotations and no output schema, the description is minimally viable but not complete. It does not explicitly say whether the tool creates a new sequence, whether it is destructive, or when to prefer it over similar siblings such as assemble_product_spot. The schema fills in parameter details, so operational context remains somewhat inferred.

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. The description adds meaningful context by framing clipPlan as explicit creative control and explaining that the optional default polish exists so creative direction can come from LLM planning rather than hardcoded passes. This goes beyond the raw schema descriptions.

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

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

The description states a clear action ('Builds a branded ad assembly') and identifies the key capabilities: real media assets, optional MOGRT overlay, clipPlan control, and optional polish. It does not explicitly differentiate from sibling tools like assemble_product_spot or build_motion_graphics_demo, 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?

The description implies when to use the tool by emphasizing LLM-driven creative direction and explicit clipPlan control, but it never names alternatives or states when not to use it. The guidance is suggestive rather than explicit, leaving the agent to infer tool selection.

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

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

With no annotations, the description must carry the behavioral burden, and it does enumerate the operations it performs: creates a sequence, lays out shots, adds dissolves, and applies scale animation. It does not disclose side effects such as whether a new sequence becomes active, whether existing timeline content is replaced, or where the stills and assets come from. It is informative at a high level but leaves key mutation behavior unstated.

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

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

The description is a single sentence that front-loads the primary actions and keeps modifiers meaningful. Every clause adds behavioral information and there is no filler or redundant restatement of the tool name. It is appropriately sized for a macro-style tool.

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

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

For a multi-step sequence-building tool with no annotations and no output schema, the description would benefit from stating what the resulting sequence is called, whether the active sequence is changed, and what source material is used. The optional sequenceName is the only input, so most behavior is fixed, but an agent cannot predict the side effects on the timeline. It covers the high-level workflow but leaves operational context 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 coverage is 100%: sequenceName is fully documented with its default value. The description itself adds no parameter-specific detail and does not mention the parameter at all. Baseline 3 is appropriate because the schema already does the work.

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

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

The description specifies a concrete multi-step deliverable: generating stills, building a sequence, laying out shots, adding dissolves, and applying scale animation. This clearly differentiates it from generic assembly tools like assemble_product_spot and build_brand_spot_from_mogrt_and_assets, even without naming them. It goes well beyond a restatement of the tool name.

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 only usage context is the final purpose clause 'for a polished minimalist ad-style demo,' which implies when this tool is appropriate. It does not explicitly state exclusions or point to alternative tools for other kinds of spots or assemblies. The guidance is therefore mostly implied rather than stated.

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

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

With no annotations, the description carries the transparency burden. It discloses that the tool scans all project items and returns a list, but it does not explicitly state whether the operation is read-only, whether there are performance implications, or whether it triggers any media refresh. 'Checks' implies no mutation, but the implication is not spelled out.

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

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

A single, front-loaded sentence that conveys the action, scope, and result 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 simple, zero-parameter diagnostic tool, the description is nearly complete: it states the input scope and the return class. It stops short of giving the exact return item format, and the ambiguity with 'get_offline_media' is not resolved, but an agent can still select and invoke this tool 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?

There are zero parameters and the schema already covers everything (100% schema coverage). The baseline for zero-parameter tools is 4, and the description does not need to add parameter-level details.

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 ('Checks'), a resource ('all project items'), and the expected output ('a list of any that are offline'). It is clear on its own, but it does not distinguish this tool from the similarly named sibling 'get_offline_media', so it misses the top score.

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 implied: call this when you need a list of offline project items. However, it gives no explicit when/when-not guidance and does not mention the seemingly equivalent sibling 'get_offline_media' or any need to refresh or relink media first.

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

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

With no annotations provided, the description carries the burden of revealing behavioral traits. It does state the operation 'clear item in out,' which implies mutating or removing in/out points, but it does not disclose which item is affected, whether selection matters, what side effects occur, or what the return state looks like. Some minimal behavior is conveyed, but not enough for a tool with no annotation safety profile.

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 very short, which is concise, but it includes the filler phrase 'Premiere Pro expanded operation' while the core phrase 'clear item in out' simply restates the tool name. It is not bloated, but it is under-specified rather than efficiently 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?

Given the large sibling toolset and no annotations or output schema, the description is incomplete. It fails to define what 'item' means, how this differs from sequence in/out operations, or what state the agent should expect before and after invocation. A tool with zero parameters is simple, but the ambiguous object of the operation leaves too much 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?

The tool has zero parameters, so the description is not required to explain parameter meaning. The empty schema with additionalProperties true is unusual, but with no parameters there is nothing to document. Baseline 4 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, 'Premiere Pro expanded operation: clear item in out,' essentially restates the tool name without defining what 'item' refers to. It does not clarify whether this applies to a selected clip, project item, or source monitor item, and the phrase 'expanded operation' adds no semantic value. This is close to a tautology and does not distinguish clearly from sibling tools like set_item_in_out or clear_sequence_in_out.

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

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

There is no guidance on when to use this tool versus alternatives such as set_item_in_out or clear_sequence_in_out. The description provides no context about prerequisites, selection requirements, or situations where this tool should be preferred. This is a clear absence of usage 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 it discloses nothing. It does not state that this operation modifies/destroys the sequence's in/out point state, what happens if no sequence is active, whether it is undoable, or what the observable effect on the timeline 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?

The description is short but this is under-specification, not conciseness. The single sentence earns no place because it merely re-states the tool name and contributes zero informative content, whereas genuine conciseness still conveys meaning 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?

The tool operates on a complex domain (Premiere Pro sequence in/out points) yet has no annotations, no output schema, and a description that says nothing beyond its own name. An agent is given no basis to understand preconditions, side effects, or the relationship to the many sequence/in-out-related sibling 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 has 0 parameters and 100% schema description coverage, so the baseline of 4 applies; there is nothing for the description to document. The schema allows additionalProperties: true, but with no declared parameters the description's silence on parameters is not a meaningful gap.

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

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

The description 'Premiere Pro expanded operation: clear sequence in out.' is essentially a tautology that restates the tool name verbatim after the colon. It adds only the vague qualifier 'expanded operation' and gives no explanation of what clearing a sequence in/out actually does, such as removing the sequence's in and out point markers from the timeline. It fails to differentiate from closely related siblings like set_sequence_in_out_points, get_sequence_in_out_points, and clear_item_in_out.

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

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

The description gives no indication of when to use this tool versus any alternative. There is no context about prerequisites such as an active sequence, no mention of how it differs from clear_item_in_out (which clears item-level in/out points), and no guidance about interaction with the work area 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 of behavioral disclosure. It only says source clips are closed, with no mention of side effects, scope (source monitor vs project vs sequence), reversibility, or expected outcomes, which is under-specified for a mutating operation.

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

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

The description is appropriately short and the core action is stated clearly. However, the leading phrase 'Premiere Pro expanded operation:' is filler that repeats domain context without earning its place, keeping it from a top score.

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, potentially destructive command with no annotations and no output schema, the description is nearly as terse as the tool name. It does not clarify what 'source clips' means, what exactly gets closed, or what the agent should expect afterward, and sibling tools like close_source_monitor and close_sequence make the ambiguity material.

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 for the description to add; schema coverage is trivially 100%. The baseline of 4 applies because no parameter-level guidance is needed.

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 identifies a specific action ('close') and resource ('all source clips'), so it is clear what the tool does. However, it does not explicitly distinguish itself from related sibling tools like close_source_monitor or close_sequence beyond the resource phrase, and 'Premiere Pro expanded operation' adds no differentiation.

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

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

There is no guidance about when to use this tool or when to prefer alternatives. It does not state that it applies to source monitor clips, nor contrast it with close_source_monitor, close_sequence, or close_project, leaving the agent to infer usage 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 of behavioral disclosure. It does not state whether unsaved changes trigger a save prompt, whether the project is unloaded from memory, or what side effects occur on sequences, bins, or source monitors. For a state-changing operation this is a critical omission.

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

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

The description is short, but this is under-specification rather than earned conciseness. The single clause adds no information beyond the tool name and provides no contextual value to earn 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 state-changing project operation with no output schema, no annotations, and no behavioral context, the description is completely inadequate. An agent cannot predict side effects such as save prompts or the resulting application state, and no comparison with close_sequence or save_project is offered.

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 zero parameters, so there is nothing for the description to clarify; the 0-params baseline of 4 applies. The empty schema with additionalProperties: true places no burden on the description.

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

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

The description "Premiere Pro expanded operation: close project" restates the tool name almost verbatim. The generic "Premiere Pro expanded operation" prefix is boilerplate that could apply to any tool in the set and does not distinguish close_project from siblings like close_sequence or save_project. It names a verb and resource but only by parroting the tool name.

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. With numerous project-management siblings (open_project, create_project, save_project, save_project_as, close_sequence), an agent has no information about the appropriate context for closing a project or what differentiates it from closing a 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It merely restates the tool name ('close sequence') and does not reveal whether the operation is destructive, whether it prompts for saving, whether it affects the active sequence only, or whether it can fail due to unsaved changes.

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 short but wasteful: 'Premiere Pro expanded operation:' is boilerplate filler that does not aid an agent's decision-making. The actual instruction 'close sequence' is minimally concise but lacks the necessary context to be genuinely useful.

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

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

Given no annotations, no output schema, and a simple but destructive-sounding operation, the description is incomplete. It does not state whether the active sequence is closed, how this relates to set_active_sequence, or what state the user sees afterward. An agent cannot determine the tool's full effect from this definition.

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 and the schema coverage is 100%, so there is no parameter ambiguity. The baseline of 4 for no-parameter tools applies, though the description adds no useful semantic detail beyond the absence of arguments.

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

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

The description states a clear verb ('close') and resource ('sequence'), so an agent can tell this operates on a sequence rather than a project or source clip. However, it does not differentiate between closing the active sequence versus a specified sequence, and the phrase 'expanded operation' adds no meaning.

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 close_project, close_source_monitor, or delete_sequence. The description gives no context about prerequisites, whether the active sequence is closed, or what happens to unsaved changes.

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, but it only names the operation. It doesn't state side effects (closing UI panel vs closing loaded clips), idempotency, or what happens when no source monitor 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?

The description is brief and front-loaded, but 'Premiere Pro expanded operation:' is boilerplate that doesn't earn its place. A concise sentence could have used that space to specify the exact behavior.

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

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

Although the operation is simple, there are no annotations or output schema to fill gaps. The description lacks the minimal context an agent needs to distinguish this command from closely related source-monitor tools and to understand its scope.

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 no parameters and the schema is empty, so there is no parameter semantics for the description to clarify. The baseline for a zero-parameter tool is 4.

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

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

The description states a clear verb and resource ('close source monitor'), so an agent can infer the basic action. However, it doesn't distinguish this from sibling tools like close_all_source_clips or open_in_source, and the 'expanded operation' phrase adds no differentiating context.

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

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

No guidance is provided on when to use this tool, prerequisites (e.g., source monitor must be open), or when to prefer close_all_source_clips. The description simply restates the action with no context or exclusions.

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

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

No annotations are provided, so the description alone must disclose behavior. It only states that adjustments are applied, not whether they are additive or overwrite existing correction, whether the operation is destructive/reversible, or what side effects occur on the clip's existing color settings.

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

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

Single sentence with no filler; the action, object, and scope are front-loaded. It is concise without losing clarity.

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 9 parameters and no output schema or annotations, the description is too thin: it doesn't say what is returned, whether the operation is destructive, or how omitted parameters behave. Important operational context is missing despite schema covering parameter syntax.

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 already describes all adjustment parameters with ranges, and coverage is 100%. The description adds no parameter-level detail, but none is needed; the schema carries the semantic weight, 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 uses a specific action ('applies ... adjustments') and explicit resource ('video clip'), and the qualifier 'basic color correction' signals a general correction operation distinct from LUT or effect-specific siblings like apply_lut. However, it doesn't explicitly state which sibling tools it should be preferred over, so it is clear but not fully differentiated.

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

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

There is no guidance on when to use this tool versus alternatives such as set_color_value, apply_lut, or set_clip_properties. No prerequisites, exclusions, or preferred scenarios are mentioned, leaving the agent to infer when color_correct is the right choice.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It discloses none: no mention of whether data is moved or copied, no side effects on source files, no project structure changes, no progress or confirmation behavior, no permissions. The word 'expanded operation' adds no concrete behavioral information.

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 short, but 'expanded operation' is filler and the wording is under-specified rather than concise. There is no structure or detail beyond a generic label, so while it's small, it doesn't earn 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?

There is no output schema, no annotations, and no parameter details, so the description must fully explain the tool's purpose and effects. It doesn't. For a complex operation named 'consolidate_and_transfer', an agent needs to know what inputs are expected (even if free-form), what gets consolidated/transferred, and what the result will be. This is completely inadequate.

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 allows any properties (additionalProperties: true), and schema description coverage is 100% in the sense there are no named parameters to describe. With 0 parameters, the description is not expected to document parameter semantics, so baseline 4 applies. It does not actively add param meaning, but there is nothing 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?

The description is 'Premiere Pro expanded operation: consolidate and transfer.' It gives a verb phrase and resource domain (Premiere Pro), but it is vague enough that it does not clearly convey what 'consolidate and transfer' does — whether it's moving media, copying projects, or archiving. It does not differentiate itself from siblings like 'consolidate_duplicates' or 'export_as_project'.

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 'consolidate_duplicates', 'export_as_project', 'move_item_to_bin', or 'export_aaf'. The description doesn't mention prerequisites, intended workflows, or conditions for use. An agent cannot decide when to invoke this tool.

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 fails to state whether the operation is destructive, whether it can be undone, what happens to the original items, or any side effects. 'Consolidates' implies mutation but gives no detail.

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 concise sentence with no filler or repetition. It is appropriately front-loaded, though the brevity contributes to the ambiguity noted in other dimensions.

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-oriented tool with no annotations, no parameters, and no output schema to clarify behavior. The description gives only a high-level action and omits consequences, scope, and relationship to siblings, leaving an agent without enough context to safely invoke 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?

The tool has zero parameters, so the description does not need to explain parameter semantics. The empty input schema covers everything, and the baseline of 4 for a zero-parameter tool 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 names a specific action ('Consolidates') and a resource ('duplicate media items'), but the verb 'consolidate' is ambiguous — it could mean merging clips, deleting duplicates, relinking, or grouping them in a bin. It does not clearly distinguish from related siblings like consolidate_and_transfer, get_duplicate_media, or apply_cleanup.

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 tool versus alternatives. No prerequisites, exclusions, or conditions are provided, and the sole sentence only restates the action without advising on 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 burden of behavioral disclosure. It merely says 'copy effects between clips' and 'expanded operation' but does not reveal which clips serve as source vs. destination, whether the operation is destructive to the destination's existing effects, whether selection state is required, or what the result looks like. This is a significant gap for a tool that must act on unstated clip targets.

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 text is short (one sentence), but brevity here reflects under-specification rather than disciplined conciseness. The phrase 'expanded operation' is filler that does not earn its place, and the sentence front-loads a vague qualifier instead of concrete behavioral detail.

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

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

With no annotations, no output schema, an open parameter schema, and no parameter documentation, the description alone must make the tool callable. It fails to explain the source/destination relationship, selection requirements, or the nature of the 'expanded' behavior. Structure is a completely inadequate 2.35 for an operation that must know which clips to act upon.

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 is an open object with `additionalProperties: true` and zero defined parameters, meaning callers could pass arbitrary properties that are completely undocumented. The description adds nothing about what parameters are accepted, such as source clip, destination clip, or effect names. The 'expanded operation' phrase does not compensate for the 0% effective parameter 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 verb ('copy') and resource ('effects') with a scope ('between clips'), which is clear at a surface level. However, 'expanded operation' is unexplained jargon that adds no meaning, and the definition does not distinguish this from the closely-related sibling `copy_effect_values`. An agent cannot tell which tool copies effect instances vs. effect parameter values.

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

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

There is no guidance about when to use this tool versus `copy_effect_values`, `batch_apply_effect`, or `apply_effect`. No mention of prerequisites such as which clips must be selected, whether a source and destination clip must be identified, or whether the active sequence matters. The context is entirely absent.

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, but it reveals nothing about side effects, clipboard behavior, whether existing values are overwritten, what counts as 'effect values,' or what the operation returns. The description is functionally as opaque as a bare verb.

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 short but not usefully concise; it spends words on the empty phrase 'Premiere Pro expanded operation' and then repeats the tool name. It under-specifies rather than being tight, and no important information is front-loaded because there is no information at all.

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

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

The tool has no annotations, no output schema, no parameter documentation, and an empty description. An agent cannot determine what inputs it needs, what it does to its environment, or what it returns. This is completely inadequate for reliable tool selection and 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?

There are zero defined parameters, so the schema provides no parameter semantics to compensate for. The description also provides none, but there is nothing to document. The baseline of 4 for zero-parameter tools applies here, though the open additionalProperties schema is slightly concerning.

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 restates the tool name almost verbatim: 'copy effect values.' It does not specify the source, destination, or scope of the copy operation, and it does not distinguish this from sibling tools like copy_effects_between_clips or set_effect_property. The phrase 'expanded operation' adds no concrete meaning.

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, what state the project or selection must be in, or what alternatives exist. The description is purely declarative and leaves the agent to guess the invocation context. This is a complete absence of usage guidance.

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

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

With no annotations, the description must stand alone, but it only repeats the operation name and gives no detail about side effects, where the bars and tone are created, or what 'expanded operation' means. The agent is left without any behavioral context beyond the name.

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 text is short but not efficiently informative: 'Premiere Pro expanded operation' is filler and the remainder basically restates the tool name. It earns little of its length, even though it is brief.

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

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

With no annotations, no output schema, and no parameters, the description is the only source of context, yet it fails to explain what bars and tone are, where they are created, or what happens after invocation. This is inadequate for an agent 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?

There are no parameters, so the baseline is 4. The description does not need to compensate for parameter documentation gaps.

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

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

The description states a clear verb and resource: 'create bars and tone' in Premiere Pro. This is specific enough to distinguish it from the many sibling create tools, though 'expanded operation' adds jargon without clarifying what is being expanded.

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

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

No guidance is given for when this tool should be used versus alternatives. Among many create-* siblings, the description does not explain how this differs or what context calls for it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the core action ('Creates'), but does not mention behavior on name conflicts, whether the parent bin must exist, what happens when parentBinName is omitted, or any return/result value.

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

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

A single sentence that front-loads the action and context with no filler. It is concise and immediately understandable, earning 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?

Adequate for a low-complexity creation tool since both parameters are documented in the schema, but it omits usage alternatives, conflict behavior, and return value. These gaps matter more given that there is no output schema and no annotations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no additional parameter-specific meaning; 'name' and 'parentBinName' are already adequately documented in the input 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 uses a specific verb ('Creates') and resource ('new bin (folder) in the project panel'), which clearly states the tool's function. The parenthetical 'folder' clarifies that this is a regular bin, distinguishing it from sibling tools like create_smart_bin, delete_bin, and rename_bin.

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 choose this tool over alternatives like create_smart_bin, or whether parentBinName should be used instead of relying on a default location. It implies the obvious case—creating a bin—but offers no conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description alone must disclose behavioral traits. It clearly states the tool mutates the sequence by creating a caption track, but it does not mention side effects (e.g., whether existing caption tracks are replaced), necessary permissions, or error behavior. This is a significant gap for a mutation tool with no annotation coverage.

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

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

The description is two sentences with no unnecessary words. The core action and prerequisite are front-loaded, and the input guidance ('Pass the SRT project item ID directly') is efficient and clear.

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

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

The description covers the main prerequisites (imported file, project item ID) and clearly states the action, which is adequate for a simple creation tool. However, it does not mention potential error conditions or return value, and with no output schema this information is absent. The related sibling read_sequence_captions suggests a caption workflow, but the description does not connect them. Overall, it is functional but not comprehensive.

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?

All four parameters are fully described in the schema (100% coverage), so the description adds minimal new meaning. It reinforces that projectItemId is the SRT project item ID and implies the file was imported via import_media, which slightly exceeds the schema. Given the high schema coverage, the baseline is 3, and the description adds a small but useful contextual nuance.

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

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

The description clearly states the verb 'Creates' and the resource 'caption track on a sequence', plus the source 'from an imported caption/subtitle file'. It is specific and distinguishes this from any sibling tool, since no other tool creates caption tracks (read_sequence_captions reads 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?

It provides a clear prerequisite: the file must be imported via import_media, and the project item ID is passed directly. It indirectly implies when to use it (when you have an SRT project item) and implicitly excludes cases without such a file. However, it does not explicitly mention alternatives or when not to use it, so it misses the full 'when-not' guidance.

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

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

With no annotations, the description carries the full burden and does so well. It explicitly discloses that originals are removed, that resulting markers have duration 0, and that the returned activeSequence identifies the actual sequence used. These are exactly the side effects and output traits an agent needs to know before invoking.

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

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

The description is compact and front-loaded with the core action, then gives the use case, destructive side effect, and output detail. No sentence is wasted; the activeSequence explanation is useful and 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 one-optional-parameter tool with no output schema, the description is complete. It explains the input prefix, the transformation, the destructive behavior, and the important return value field, plus why that field matters. Nothing essential is missing for correct invocation.

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

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

Schema coverage is 100%, so the schema already documents the single optional prefix parameter and its default. The description re-states the default but adds no meaningful semantics beyond what the input schema provides, matching the baseline for full 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?

States a specific verb and resource: converting duration markers into POINT markers of type MARKER_TYPE_CHAPTER. The phrase 'Originals are removed after the chapter markers are created' further distinguishes this from generic marker add/remove siblings, so an agent can select it correctly without opening other tools.

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

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

Provides a clear use case: turning 'Scout/Key:' moments into YouTube/podcast chapter markers. It does not explicitly name alternatives or exclusion conditions, but the intended context is concrete and readily actionable.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a project is created and does not explain side effects such as whether the current project is closed, whether an existing file is overwritten, whether the project is opened afterward, or what the return value indicates.

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

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

Two sentences with no filler. The action is stated first, followed directly by the usage condition. Every sentence earns its place.

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

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

For a simple two-parameter tool with fully documented schema, the description provides the essential purpose and usage. However, with no annotations and no output schema, it omits behavioral details that an agent should know, such as what happens to the currently open project or whether the new project becomes active.

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 documents both 'name' and 'location' with examples. The description adds no additional parameter-level meaning, so the baseline score 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 ('creates') with a clear resource ('a new Adobe Premiere Pro project'), and 'from scratch' further distinguishes it from operations like open_project, save_project, or create_sequence. An agent can immediately identify this as the tool for creating a brand-new project.

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

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

The description explicitly states when to use it: 'when the user wants to start a new video editing project from scratch.' It provides clear use context, though it does not mention exclusions or alternatives like open_project for existing projects.

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 for behavior and does add value by noting that the native New Sequence dialog is not opened. It does not disclose side effects such as whether the new sequence becomes the active sequence, what happens on invalid preset paths, or whether existing project state is affected. 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 two sentences with no wasted words. It front-loads the core purpose and behavioral detail, then immediately provides alternative routing for different use cases.

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 fully documented parameters, the description provides enough context for selection and invocation. It omits return value or error behavior, but the simple scope and clear alternatives make that gap minor.

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

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

Schema coverage is 100%, so both parameters are already fully documented. The description's mention of an installed .sqpreset file adds slight context, but the schema already explains the absolute path requirement and its role in suppressing the dialog. This matches the baseline for fully covered schemas.

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 action: creating a new sequence from an installed .sqpreset file, and explicitly mentions avoiding Premiere's New Sequence dialog. It also distinguishes the tool from create_sequence_from_clips and duplicate_sequence, but it does not differentiate it from the sibling create_sequence_from_preset, which appears semantically similar.

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 explicit when-not guidance by recommending create_sequence_from_clips for footage-driven edits and duplicate_sequence with clearContents=true for empty copies of existing sequences. However, it does not explicitly state when to prefer this tool over create_sequence_from_preset, so it falls just short of complete usage differentiation.

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, but it only says a sequence is created from clips. It does not disclose whether clips must be selected first, whether the operation is destructive, what happens to existing sequences, or what the return value is. 'Expanded operation' hints at additional behavior but never explains it.

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 short, which aids readability, but the prefix 'Premiere Pro expanded operation' adds little value and the meaningful phrase 'create sequence from clips' appears after that filler. It is not bloated, yet it is too sparse to be considered well-structured guidance.

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

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

This is a mutation tool with no annotations, no output schema, and no parameter documentation. The description does not explain how the source clips are determined, what state changes occur, or how success is reported. Given the sibling list includes several closely related sequence-creation tools, the description is not complete enough for an agent to invoke 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?

The schema has zero formal parameters and 100% coverage, so the baseline is 4 for this dimension. The description contributes only the notion that clips are the input source, without detailing how clips are specified; however, with no declared parameters, that is an acceptable 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 states a clear action and resource: 'create sequence from clips.' It is not a pure tautology because it adds the source of the sequence content, distinguishing it from generic sequencing tools. However, the phrase 'expanded operation' is vague and does not explicitly differentiate this from siblings like create_sequence or create_sequence_from_preset.

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 such as create_sequence, create_subsequence, or create_sequence_from_preset. There is no mention of prerequisites like selected clips, active bins, or project state. Usage is only weakly implied by the tool name itself, not explained.

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 bears the full burden of explaining side effects, prerequisites, and behavior. It only says a sequence is created from a preset, leaving unclear whether the preset is selected by name, whether it requires an active project, whether the new sequence becomes active, or whether existing content is affected.

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 brief and front-loads the core action, which is good for scannability. However, 'Premiere Pro expanded operation:' is filler and adds no decision-relevant information beyond the phrase that follows.

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

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

The tool has no annotations or output schema, and this is a mutation operation, so the description should explain prerequisites, expected preset source, and result behavior. It provides none of that, leaving an 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?

The schema declares zero defined parameters and the description does not need to explain parameter details. The high schema coverage supports a baseline score of 4; the only minor issue is that 'preset' is mentioned conceptually without specifying how it is identified, but that is not required because no parameters are defined.

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

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

The description clearly states the action and object: 'create sequence from preset', which distinguishes it at a surface level from generic sequence creation tools like create_sequence. However, it doesn't explicitly contrast with similar siblings such as create_sequence_from_clips or create_subsequence, so it stops short of full differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. The phrase 'expanded operation' hints at a broader/advanced variant but never states the condition for choosing it over create_sequence, create_sequence_from_clips, or set_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 entire burden of behavioral disclosure, and it discloses nothing: no side effects, no requirements, no return value, and no note about whether criteria are set programmatically. The phrase 'expanded operation' hints at non-obvious behavior but says nothing concrete.

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 very short, which is structurally fine, but 'Premiere Pro expanded operation' is boilerplate filler that doesn't earn its place. It is concise without being 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?

For a tool with no output schema, no annotations, and a large sibling set, this description is far too thin: it omits what a smart bin is, how criteria are provided, how creation is confirmed, and how it differs from create_bin. An agent cannot reliably invoke or validate the result with this information.

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 defined parameters and no required parameters, so there is no parameter schema for the description to supplement; the 0-parameter baseline of 4 applies. The odd 'additionalProperties: true' openness is not explained, but with no declared params the description could add little here.

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

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

The description states the verb and resource ('create smart bin'), so a human can infer the basic operation, but it adds little beyond the tool name. The phrase 'Premiere Pro expanded operation' is unexplained, and no mention is made of what distinguishes a smart bin from the sibling create_bin, leaving the purpose only partially 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 tool rather than create_bin or other bin-related siblings, and no mention of prerequisites or how to specify bin criteria. The agent is left to infer appropriate usage 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 provided, the description carries the full behavioral disclosure burden. It clearly identifies a mutating create operation, but it does not state whether the source item is modified, what happens on invalid in/out points, or what the tool returns. For a mutation tool with zero annotation coverage, 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 description is a single efficient sentence with no filler. It front-loads the core operation, the source object, and the key parameter concept.

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 covers parameter semantics well, but the absence of any output schema and annotations means the description should clarify what happens after creation, where the subclip appears, or whether the source is affected. The description is minimally viable but leaves these contextual gaps.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds only a light mapping of 'in/out points' to startTime and endTime. This meets the baseline but does not provide additional meaning beyond the schema.

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

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

The description states a specific verb ('Creates'), a specific resource ('a subclip'), and the source ('a project item') with explicit in/out point behavior. This clearly separates it from sibling tools like create_subsequence or set_item_in_out without needing to read the schema.

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

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

No guidance is provided for when to use create_subclip versus alternatives such as create_subsequence, set_item_in_out, or other editing tools. Usage is only implied by the tool's name and basic description, with no context, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but not what happens after creation: where the subsequence lands, whether the source sequence is modified, what occurs if no in/out points exist, or the effects of ignoreTrackTargeting. For a creation tool with side effects, this is a notable 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 12-word sentence with zero filler. The verb is front-loaded, and every word contributes meaning — 'from the in/out points of a sequence' is essential context rather than padding.

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 (two params, both fully documented in schema), so the description is adequate for the basic operation and prerequisite. However, with no output schema and no annotations, the missing behavioral context — result placement, error conditions, and side effects — leaves an agent without enough information to confidently 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 the baseline is 3; the schema already documents both sequenceId and ignoreTrackTargeting. The description adds minimal extra meaning by identifying 'in/out points' as the substance of the operation, but it does not clarify how ignoreTrackTargeting affects the result beyond the schema's terse wording.

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 ('creates') with a clear resource ('subsequence') and states the derivation source ('from the in/out points of a sequence'), so an agent understands the core operation. However, it does not differentiate from the closely named sibling create_subclip, which likely produces a similar derived media 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 phrase 'from the in/out points of a sequence' implies a prerequisite — the source sequence must already have in/out points set — which is usable context for an agent deciding to call this tool. But there is no explicit guidance on when to prefer this over create_subclip or create_sequence, and no stated exclusions.

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

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

With no annotations, the description carries the behavioral burden and does well: it reveals the non-obvious reuse-or-add behavior and clarifies that omitted parameters retain current/default values. It does not discuss broader side effects, but the core runtime behavior is transparent.

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

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

Three sentences with no filler: the action and resource lead, the reuse behavior is explained, and the default handling is stated. Every sentence adds necessary information.

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

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

Given the tool's moderate complexity and no output schema, the description covers the essential behavior and default semantics well. It does not mention prerequisites like clip type or return value, but these are minor for an edit operation with fully documented parameters.

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 documents all seven parameters (100% coverage), so the baseline is 3. The description adds meaningful cross-parameter semantics by stating that omitted parameters keep their current/default values, which clarifies how partial crop specifications behave beyond the individual schema descriptions.

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 action ('Crops a timeline clip'), the exact mechanism (Premiere Pro's built-in Crop video effect), and clears up ambiguity by stating it reuses an existing Crop effect or adds one. This clearly distinguishes crop_clip from generic sibling tools like apply_effect or set_clip_properties.

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 what it does but gives no explicit guidance on when to choose it over alternatives such as apply_effect or list_clip_effects. There is no mention of scenarios where another tool would be preferable, leaving the agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether deleting a bin also deletes its contents, whether the operation is reversible (e.g., undoable), whether confirmation is required, or what side effects occur. The description is silent on all behavioral aspects, which is especially risky for a destructive 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 short phrase that provides no structured information. While it is concise, it is under-specified to the point of being unhelpful. It does not front-load any useful detail and fails to earn its place as a meaningful description.

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

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

For a destructive tool with no annotations and no output schema, the description is severely incomplete. It omits critical context such as what a bin is, how deletion behaves, what input is required, and whether the action is safe or reversible. An agent cannot confidently invoke this tool based on the current description alone.

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

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

The input schema is essentially empty but allows additional properties. The description does not explain what parameters are expected (e.g., bin name or ID), how to specify the target bin, or any constraints. With no parameter documentation and a permissive schema, the agent has no idea what to pass. The baseline of 4 for zero parameters is not applicable because the schema leaves room for arbitrary input but the description offers no guidance.

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 'Premiere Pro expanded operation: delete bin' essentially restates the tool name without adding detail. It lacks specificity about what a 'bin' is in this context, what the deletion entails, or how it differs from sibling tools like 'delete_multiple_project_items' or 'move_item_to_bin'. It conveys only the surface action, not the precise scope or target.

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

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

No guidance is provided on when to use this tool versus other deletion-related tools. There is no mention of prerequisites, such as whether a bin must be selected or named, or when an alternative like 'move_item_to_bin' or 'delete_multiple_project_items' would be preferred. The agent is left with no decision support.

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 of behavioral disclosure. It does reveal one non-obvious behavior: the target sequence does not have to be active. However, it does not mention whether deletion is permanent/irreversible, what happens if the marker does not exist, or any undo implications, which are relevant for a delete 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 two sentences with no filler. The primary action and the most important scoping caveat are both front-loaded, making it easy for an agent to parse quickly.

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 delete operation, the description covers the core action and sequence scoping. However, with no annotations, no output schema, and no mention of how to discover marker IDs or when to use remove_markers instead, there are notable gaps that an agent must resolve elsewhere.

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 both parameters already have clear descriptions, so the bar is at baseline 3. The description adds little beyond what the schema already states for sequenceId and markerId. The 'does not have to be active' note is useful but largely reiterates that list_sequences can supply sequence IDs.

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 ('Deletes'), a resource ('a marker'), and the scope ('from the specified sequence'). It also adds the useful detail that the sequence need not be active. However, it does not explicitly distinguish itself from the sibling tool 'remove_markers', so an agent may still need to 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?

The line 'The sequence does not have to be the active one' gives useful context about when this tool is applicable, especially for non-active sequences. But it provides no explicit guidance on when to prefer this over 'remove_markers' or how to obtain marker IDs via list_markers / get_sequence_markers_by_type. Usage guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a destructive action, but does not say whether the deletion is permanent, whether it can be undone, whether it requires a selection, or what constraints apply. The absence of these details is significant for a mutating 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 a single, short sentence and is easy to scan. However, the 'Premiere Pro expanded operation:' prefix is not clearly valuable and uses words without adding concrete meaning. Overall it is concise, but not 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 destructive tool with no annotations, no output schema, and no parameters, the description is too sparse. It never explains how the target items are determined, what the preconditions are, or what happens after deletion. An agent cannot reliably decide when to call this tool or what state it depends on.

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 declares zero parameters, so there is no parameter documentation burden on the description. The schema's additionalProperties: true is unusual, but with no defined parameters the description does not need to provide parameter-level meaning. A score of 4 reflects the zero-parameter baseline.

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

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

The description uses a specific verb and resource: 'delete multiple project items'. It distinguishes the operation from sibling tools like delete_bin and delete_sequence by naming project items, though it does not explicitly contrast with those alternatives. The phrase 'Premiere Pro expanded operation' adds little and could confuse, but the core purpose is 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 about when to use this tool versus alternatives such as delete_bin, delete_sequence, remove_selected_clips, or delete_marker. The description does not state whether this operates on selected project items, a supplied list, or some other context. An agent is left to 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 of behavioral disclosure. It simply states 'delete preview files' without mentioning that this is destructive, what exactly is deleted (e.g., disk files vs. project metadata), whether it can be undone, or any side effects on the project. This is a critical omission for a deletion 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 a single concise sentence, front-loading the action. It is appropriately sized for a simple tool, though it lacks the detail expected for a destructive operation. There is no redundancy or fluff.

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

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

For a deletion tool with no annotations, no parameters, and no output schema, the description is too sparse to inform an agent of necessary context. It does not mention prerequisites (e.g., active sequence/project), what happens after deletion, or any side effects. Compared to other tools in the suite, this lacks completeness.

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 and schema coverage is 100% (since there is nothing to cover). Per the rubric, 0 params yields a baseline of 4. The description adds no parameter information, but there are no parameters to explain, so this is acceptable. The additionalProperties:true flag is not addressed, but it is not a defined 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 description states a clear verb (delete) and resource (preview files), identifying the tool's function. It distinguishes itself from siblings by naming 'preview files', a specific resource not mentioned in any other tool. However, it does not elaborate on what preview files are or the scope of deletion, so it lacks some specificity.

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, no prerequisites, and no mention of context (e.g., must have a sequence open). The description provides no exclusions or alternative routing, leaving the agent to infer usage. This is a significant gap given the verbose sibling list.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly communicates a destructive side effect by saying 'Deletes', which is adequate, but it does not disclose whether deletion is permanent, whether undo is possible, or what happens if the sequence is currently open or active.

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. Every word contributes to conveying the operation, and it is appropriately sized for a simple one-parameter delete 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?

The tool is simple and its single parameter is documented, but there is no information about return behavior, error conditions, or preconditions such as whether the sequence must be closed before deletion. It is minimally complete but lacks meaningful 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?

The input schema already documents the only parameter fully: 'The ID of the sequence to delete'. The tool description adds no additional parameter meaning, so the baseline score of 3 is appropriate given the 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 uses a specific verb ('Deletes') and a specific resource ('a sequence from the project'), making the tool's function immediately clear. It also distinguishes this from sibling tools like create_sequence, duplicate_sequence, and close_sequence without needing to open any schema.

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

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

There is no guidance about when to use this tool versus alternatives such as delete_multiple_project_items, remove_selected_clips, or close_sequence. The description simply states the action without explaining context, prerequisites, or exclusions.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It merely restates the operation without explaining whether it clears the active sequence selection, affects linked audio/video items, or what happens when no sequence 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?

The description is very brief and front-loaded, but most of its content restates the tool name. The phrase 'Premiere Pro expanded operation' is generic filler that adds little informational value.

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

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

For a zero-parameter selection operation, a short description can be minimally sufficient, and the core action is present. However, with no annotations and no mention of the active-sequence context or selection side effects, it is only barely 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 has zero parameters and an empty input schema, so the no-parameter baseline applies. There is no parameter semantics burden for the description to carry.

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

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

The description states a clear action and resource: 'deselect all clips.' It is not misleading and is distinguishable from the opposite select_all_clips tool, but it does not explicitly call out sibling tools or conditions that differentiate it, so it stops short of the highest rating.

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

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

No guidance is given about when to use this tool versus alternatives such as select_all_clips, invert_selection, or set_clip_selection. The description provides no context, exclusions, or alternative routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether this removes proxy links, modifies media files, is reversible, or what side effects occur. The agent gets no more information than the tool name itself provides.

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 short and free of redundant explanation, but the prefix 'Premiere Pro expanded operation' is unnecessary filler. It is concise rather than informative, and the space could have been used for 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?

The tool has no output schema and no annotations, so the description is the only source of context. It fails to clarify what object the operation targets, what happens after detaching, or how this fits with related proxy workflows. The low complexity prevents a score of 1, but the description is still minimal.

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 are zero parameters, so the schema already fully documents the call signature. The description does not need to add parameter-level meaning, and no gaps exist for it to fill.

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 and resource ('detach proxy') making the tool's action clear. However, the phrase 'Premiere Pro expanded operation' is generic and does not differentiate this from related proxy tools like has_proxy.

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

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

No guidance is provided about when to use this tool, what prerequisite state is required (e.g., a clip with an attached proxy), or how it compares to alternatives such as has_proxy. The description merely restates the action without 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 must disclose behavior on its own. It mentions optional cuts or markers, but does not warn about potential blocking, synchronous execution, the async/sync behavior referenced by allowUnsafeSynchronous, effects on the timeline, or whether detection without an action is read-only. This leaves significant behavioral risk undisclosed.

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 communicates the core operation without wasted words. However, it is slightly under-specified for the tool's complexity, which prevents a full 5.

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

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

Given no output schema, no annotations, and a 5-parameter tool, the description is incomplete. It does not explain what the tool returns, whether it blocks, what happens with no selected clips, or whether markers/cuts replace or append to existing content. The agent is left to infer critical invocation 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 the baseline applies. The description adds little beyond the schema, though the phrase 'optionally adds cuts or markers' loosely maps to the action enum and offers some semantic reinforcement. No parameter details or formats are added.

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

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

Description states a specific action (detects scene changes) on a specific resource (selected clips) with an optional outcome (cuts or markers). This is clear and distinct from silence detection, though it doesn't explicitly differentiate itself from the similarly named 'scene_edit_detection' sibling.

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

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

No guidance is given about when to use this tool versus alternatives. The description implies usage when scene changes are needed, but it never states prerequisites (e.g., clips must be selected) or when to prefer the sibling scene_edit_detection tool.

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

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

With no annotations, the description carries full burden and does so thoroughly: it reveals it runs locally via child_process rather than through Premiere's API, requires ffmpeg on PATH, fails with an explicit error if ffmpeg is missing, and performs no cutting or modification. It also explicitly says all audio tools in the codebase only write levels and never read them, which is valuable behavioral context.

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

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

The description is front-loaded with the core function, then efficiently covers the key caveat about Premiere's API, the ffmpeg dependency, the non-destructive behavior, and downstream usage. Every sentence adds distinct value and none is redundant with 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?

For a tool with no annotations and no output schema, the description covers nearly everything an agent needs: dependencies, failure mode, side effects, and follow-up actions. The only minor gap is that the returned 'intervals' are not structurally described (e.g., start/end fields), though the name and usage are clear enough for most 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 coverage is 100%, so the schema already documents all four parameters and defaults. The description mostly restates those semantics (direct path vs project item ID, dBFS threshold, minimum duration) but does not add substantial new meaning 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 clearly states a specific action ('Analyzes a media file's audio for silent stretches') using a named implementation (ffmpeg's silencedetect filter). It explicitly distinguishes itself from write-only audio tools in the codebase and from any Premiere scripting API, and clarifies it is detection-only, so an agent can tell it apart from sibling editing tools.

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

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

The description gives explicit context for when to use this tool: when silent stretches need to be detected, and notes that Premiere's own scripting API cannot do this. It also names the follow-up tools (split_clip/ripple_delete/razor_timeline_at_time) if removal is desired, and states prerequisites like ffmpeg on PATH.

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 present, so the description must disclose behavioral traits. It only states that a clip is duplicated; it does not mention whether the original is preserved (though implied), where the duplicate appears beyond the schema's offset default, whether the clip is selected afterward, or any undo/selection side effects. It provides no behavioral context beyond the minimal action.

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 concise, front-loaded sentence with no filler. Every word contributes to the tool's core purpose.

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 tool with complete schema coverage, the description plus schema is nearly sufficient to invoke it correctly. However, there is no mention of return values, side effects, or preconditions, and with no annotations the description alone leaves an agent slightly under-informed about the 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 the input schema already documents clipId and offset, including the default placement after the original. The description adds no parameter-level semantics, but the high-coverage schema carries that burden, 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 uses a specific verb and object ('Duplicates a clip') and anchors it to a resource ('on the timeline'), which clearly distinguishes it from sibling tools like duplicate_sequence and consolidate_duplicates. Even without a title, an agent knows exactly what this tool does.

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

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

No guidance is given on when to choose this tool over alternatives such as duplicate_sequence, consolidate_duplicates, or copy-based operations. The context is implied by the name and description, but no explicit when/when-not conditions are provided.

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 clearly discloses that the operation copies the sequence, that clearContents=true yields an empty copy, and that the copy inherits frame rate, resolution, and track layout. It notably explains the create_sequence limitation. It does not cover name-conflict behavior or return value, but core mutation behavior is well conveyed.

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

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

Two sentences with no filler. The first sentence states the core operation, and the second adds a high-value usage caveat with a crisp contrast to create_sequence. Every sentence earns its place.

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

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

For a low-complexity tool with full schema coverage, the description is nearly complete: it covers purpose, parameter semantics, default behavior, and the key alternative. Minor gaps such as name collisions or return behavior are not critical for correctly selecting and invoking the tool.

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

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

Schema coverage is 100%, so the schema fully documents all three parameters. The description adds practical rationale for clearContents=true and names the inherited settings, but it largely reinforces what the schema already says rather than adding new parameter meanings. Baseline 3 is appropriate.

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

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

States a specific verb and resource: 'Creates a copy of an existing sequence with a new name.' This unambiguously distinguishes it from related siblings like delete_sequence, duplicate_clip, and create_sequence while also naming the create_sequence alternative in the same description.

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

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

Explicitly tells the agent when to use the clearContents=true path and why: to get an empty, correctly-specced blank target when create_sequence would ignore frame rate. This is concrete, decision-relevant guidance that names the alternative tool and the condition that selects it.

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

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

With no annotations, the description carries the full burden. It discloses the exact effect (sets disabled=false), the undo behavior (single undo entry, Ctrl+Z), the no-op nature on already-enabled clips, and the return value (activeSequence object). This is comprehensive and goes beyond what the schema (empty) or annotations (none) provide.

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 well-structured, front-loaded with the primary action, then the use case, then behavioral details (undo, no-op, return). Every sentence adds value; there's no fluff. It is appropriately detailed for a no-argument tool without being verbose.

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, no-output-schema tool, the description covers everything an agent needs: what it does, when to use it, side effects, safety, and the return structure. It even hints at comparing activeSequence across calls to detect sequence switches. No additional context is needed for 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?

There are zero parameters, and the description correctly confirms 'No arguments'. Since the schema already reflects this (100% coverage, no properties), the description adds no parameter details—but none are needed. The baseline for 0 params is 4, as there is nothing 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?

The description clearly states the verb and resource: 'Enable every clip on every video and audio track of the active sequence'. It specifies the exact operation (sets disabled=false) and provides a concrete use case (Multi-Cam edits, Lift, manual disables). This distinguishes it from partial operations like batch_enable_disable, which the description implicitly contrasts by emphasizing 'every clip' and 'no enabled some, disabled some 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?

The description gives explicit context for when to use it: after operations that disable many clips, when the user wants to restore all at once. It also provides safety guidance ('safe to run on any sequence' due to no-op on already-enabled clips). However, it does not explicitly name alternative tools like batch_enable_disable or state when NOT to use it, so it stops short of a 5.

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

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, but it only restates the action. It does not explain what disabling a clip means (e.g., whether it stays on the timeline, affects playback or export), nor does it mention reversibility 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?

The description is a single, front-loaded sentence with no filler. It conveys the core operation efficiently and is appropriately sized for such a simple 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?

The description plus schema is minimally sufficient for an agent to invoke the tool with the correct parameters. However, it lacks guidance on when to prefer this over related sibling tools and does not define the behavioral consequences of disabling a clip, leaving it only minimally viable.

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 covers both parameters at 100%, so the baseline is 3. The description adds useful context by saying 'on the timeline,' clarifying that clipId refers to a timeline clip rather than a project item, which is valuable given the large sibling set.

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-resource action: enabling or disabling a clip on the timeline. It is understandable on its own, though it does not explicitly differentiate itself from sibling tools like batch_enable_disable or enable_all_clips beyond the singular 'a clip'.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention that this is for individual clips only, nor does it reference batch_enable_disable or enable_all_clips when multiple clips need to be toggled.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It reveals nothing about side effects, required permissions, return values, or what encoding entails, making it impossible to predict the tool's runtime behavior.

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

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

While the description is short, it is under-specified rather than concisely informative. The phrase 'Premiere Pro expanded operation' is filler, and the core content merely repeats the tool name without structure or front-loaded actionable details.

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, no output schema, and an empty parameter schema, this description needed to explain the purpose, behavior, and expected inputs/outputs. It does none of that, so an agent has essentially no information for invoking the tool 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?

The input schema declares zero documented parameters, and the rule grants a baseline of 4 for zero-parameter tools. The description adds no parameter information, but with no parameters to explain, there is little semantic burden to fulfill. The open additionalProperties: true is noted in the schema but not clarified by the description.

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

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

The description is essentially a tautology: 'encode file' restates the tool name with no clarifying verb-resource relationship, no scope, and no distinction from sibling encoding tools like encode_project_item or start_batch_encode. It adds only the vague label 'Premiere Pro expanded operation,' which does not explain what the tool actually does.

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

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

There is no guidance about when to use this tool versus alternatives such as encode_project_item, export_sequence, or start_batch_encode. The description does not provide context, prerequisites, or exclusions, leaving the agent without any basis for choosing this tool.

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 does not say whether encoding is synchronous, whether files are written, whether it operates on the selected item, or whether it requires a specific project state.

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 terse, but 'Premiere Pro expanded operation' is filler and the remainder merely restates the tool name. It is under-specification rather than carefully structured 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?

For a no-parameter operation, an agent still needs to know what state is required (e.g., a selected project item), what side effects occur, and what result to expect. There is no output schema and no behavioral description to fill these 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 zero documented parameters, so there is no parameter detail the description must add. The no-parameter baseline of 4 applies; the loose additionalProperties:true is not documented as supported input.

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 supplies a verb and a resource ('encode project item'), so an agent can infer the broad purpose. However, 'expanded operation' is opaque, and the description does not distinguish this from sibling tools like encode_file or start_batch_encode.

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

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

No guidance is given about when to use this tool rather than encode_file, start_batch_encode, export_sequence, or add_to_render_queue. The phrase 'expanded operation' provides no practical 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 provided, the description carries the full burden and does so well: it discloses independent eval with no shared state, availability of QE DOM, no undo grouping, and the full destructive capability. This is exactly the behavioral context an agent needs before invoking an arbitrary-code 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 dense but every sentence earns its place: core function, return contract, state semantics, structured-result guidance, and a warning. It is front-loaded with the most important information and contains no filler.

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

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

Despite having no annotations and no output schema, the description covers the essential operational facts: what the tool runs, what it returns, its state isolation, and its risk profile. An agent has enough information to decide whether and how to call it, including how to format complex results.

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

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

The schema already fully documents the single script parameter, so the baseline is 3. The description adds value by requiring the script to be self-contained and recommending a JSON-shaped string for structured results, both of which help the agent construct correct invocations.