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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It discloses that both video and audio are affected and that fades go to/from black, which is useful. However, it does not clarify what happens if no fade durations are supplied (e.g., does it error or do nothing?) or whether output_path is required to avoid overwriting the input file. These gaps prevent a higher score.

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

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

The description is a single, well-structured sentence that conveys the core functionality without any redundant or tangential information. It is front-loaded and 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?

Given the tool's relative simplicity (4 parameters, no nested objects, no output schema), the description covers the primary use case but leaves some edge cases unaddressed, such as default behavior when both fade_in and fade_out are omitted and the exact role of output_path (whether it is required or defaults to overwriting). This is a moderate gap in completeness, so a score of 3 is appropriate.

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 100% description coverage for all four parameters, so the baseline is 3. The description does not add additional parameter-level semantics beyond what the schema already states; it merely rephrases the fade_in/fade_out durations implicitly via 'start and/or end.'

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 the specific verb 'Fade' and clearly identifies the resource ('the video (and its audio)') and the exact behavior ('in from black at the start and/or out to black at the end'). This makes the tool's purpose unmistakable and distinguishes it from sibling video editing tools like trim_video or convert_video.

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

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

The description provides clear context that this tool is for adding fade effects, which implicitly tells an agent when to use it. However, it does not explicitly mention alternatives or exclusions, such as 'use trim_video for cutting segments instead.' The absence of explicit alternatives is not misleading, so this is a 4 rather than a 5.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only mentions the ability to limit text to a time range, but does not state whether the operation creates a new file, overwrites the input, preserves audio, or what happens if no start/end is given (presumably text appears throughout the entire video). These are important behavioral traits for a video editing 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 extremely concise, consisting of two short sentences. It front-loads the primary purpose and adds the time-range detail without unnecessary words or repetition.

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

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

With 9 parameters and no output schema, a richer description is needed. The current description only covers the general purpose and optional time range, but does not explain return values, error behavior, output file handling, or any processing details like re-encoding. This is inadequate for a tool with such complexity.

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

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

Schema description coverage is 100%, so all parameter semantics are already documented in the schema. The description adds no extra parameter meaning beyond the mention of an optional time range, which maps to the start and end parameters. This meets the baseline but does not enhance it.

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 draws text on a video and gives examples (caption, title, label). It also mentions the optional time-range limitation. However, it does not explicitly distinguish itself from sibling tools like burn_subtitles or add_watermark, which could also involve text placement.

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. It does not mention that burn_subtitles might be for subtitle files or that add_watermark is for watermarking, leaving the agent without clear selection criteria.

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 restates the core operation without explaining side effects: whether the source video is modified or a new file is created, how the output_path default works (it is not required in the schema), or any preconditions like codec compatibility. This is a significant gap for a tool that writes output.

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 of 16 words, front-loaded with the verb 'overlay' and the resource. It is concise, well-structured, and contains zero filler, 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?

Despite a rich schema, the description omits important context: it does not clarify that this is a video-processing operation that produces a new file (output_path is optional but not explained), nor does it describe the return value or how transparency in the watermark image is handled. The relationship to sibling tools like picture_in_picture is also unaddressed, leaving the agent to infer when to select this 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?

The input schema has 100% description coverage, with all six parameters documented including defaults and enum values. The description adds no additional meaning beyond mentioning 'size and opacity,' which are already covered by the width and opacity schema descriptions. Thus, 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 the tool overlays an image (logo/watermark) onto a video, specifying corner placement and optional size/opacity. This is a specific verb+resource that distinguishes it from sibling tools like add_text_overlay or draw_box, which handle text or shapes instead of images.

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

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

The description implies the tool is used when the user wants to add an image watermark to a video, with clear context about corner positioning and sizing options. However, it does not explicitly mention when not to use it or provide alternatives such as add_text_overlay for text-based watermarks, so it lacks explicit 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, but it only mentions neutral values and the saturation 0 = black & white behavior. It does not state whether the original file is overwritten, what happens if output_path is omitted, or any side effects, leaving important behavioral aspects 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?

The description is extremely concise: two sentences that front-load the primary action and then provide essential neutral-value context. Every word earns its place, and there is no repetition of schema 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?

The schema fully documents all parameters, and the description explains the core purpose and neutral defaults. However, the description does not address the optional output_path behavior—specifically what happens if it is omitted—which is a notable gap for a tool that likely writes files. The overall picture is adequate but not fully complete.

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

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

Although the schema already provides full parameter descriptions with ranges and defaults, the description adds a unifying concept of 'neutral values' and explicitly clarifies that saturation 0 equals black & white. This goes beyond the schema by helping the agent reason about combinations and intended default behavior.

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 ('Tune') and clearly identifies the resource being modified (brightness, contrast, saturation), which distinguishes it from sibling tools like adjust_volume or resize_video. It directly conveys the tool's purpose without ambiguity.

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

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

The description implies the tool is for color adjustments through the phrase 'Tune brightness, contrast, and/or saturation,' but it does not explicitly state when to use it instead of alternatives or provide any exclusions. The context is clear enough for basic selection, but there is no explicit guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral trait: video is untouched, and explains that audio is scaled by a factor. However, it does not mention output behavior, supported formats, or whether the operation is destructive to the source, though the output_path parameter somewhat implies writing a new file.

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 core action and includes a practical example. Every phrase earns its place, and it is efficiently structured.

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

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

For a simple tool with full schema coverage, the description is reasonably complete. It covers the operation, the multiplier semantics, and the crucial caveat about video remaining untouched. It lacks explicit mention of input/output path handling, but the schema fills that gap.

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

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

The schema already documents all parameters with descriptions, so baseline is 3. The description adds semantic meaning to the 'factor' parameter by explaining that 2 means double and 0.5 means half, which goes beyond the schema's generic examples. This is useful clarification that improves parameter understanding.

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 function: making audio louder or quieter. The multiplier examples and the note that video remains untouched provide specific scope that distinguishes it from video-editing siblings. This is specific verb+resource with clear 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 explains how to use the multiplier but does not mention when to choose this tool over alternatives like normalize_audio. There is no explicit guidance on exclusions or alternative tools for similar audio adjustments. The usage context is implied rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It adds that the operation is 'optionally limited to a time range,' which is useful behavioral context not in the schema. However, it does not disclose output behavior (whether input is overwritten or output_path is required), which matters for an edit operation. The description also doesn't mention that mode defaults to blur, though the schema covers that.

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 with an em dash, front-loading the core action and then giving use cases. It is concise and contains 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?

With 10 parameters and no annotations/output schema, this is a moderately complex tool. The description gives a clear high-level purpose and mentions the optional time range, but doesn't cover output-path handling or coordinate/time formats (though schema covers parameter details). For an edit tool, a note on output behavior would enhance 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 input schema has 100% parameter description coverage, so the schema already documents all 10 parameters. The description adds implicit context by referring to 'rectangle of the frame' (x/y/width/height) and 'time range' (start/end), but doesn't go beyond the schema. With complete schema coverage, 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 the tool's function: 'Blur or pixelate a rectangle of the frame' with specific use cases (faces, license plates). This is a specific verb+resource that distinguishes it from sibling tools like crop_video or draw_box, which serve different purposes.

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 use-case context: 'for hiding faces, license plates, names, or other sensitive content.' It implies when to use this tool (obscuring sensitive content) but does not explicitly mention alternatives or when not to use it. Given the sibling tools like crop_video and draw_box, explicit exclusions would strengthen 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 present, so the description must carry the behavioral burden. It mentions 'permanently' and 'render', but does not disclose whether the input video is modified, what happens if output_path is omitted, or any side effects. This is a mutating operation needing more 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, front-loaded sentence that is concise, factual, and contains no filler or redundant 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?

There is no output schema and no annotations. The schema leaves output_path optional, but the description fails to mention what happens when it is omitted or whether input is overwritten. Given the mutating nature and the existence of many sibling tools, the description is incomplete without these details.

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 and the schema already explains each parameter. The description adds context about subtitle formats and that they are burned onto frames, but does not explain details like font_size only applying to .srt or output_path defaults.

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 ('render') and resource ('subtitle file ... onto video frames'), names supported formats (.srt or .ass), and emphasizes 'permanently', making it clearly distinct from sibling tools like add_text_overlay or add_watermark.

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 is implied that this tool is for burning subtitle files, which contrasts with text overlay tools, but there is no explicit when-to-use guidance, no exclusions, and no mention of alternative tools for similar tasks.

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 discloses a key non-obvious behavior: audio pitch is preserved. However, it does not mention side effects like file overwriting or what happens if output_path is omitted, leaving some 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?

Two sentences, no filler. The first sentence states the main action, the second clarifies the factor parameter with concrete examples. Very efficient.

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

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

For a simple transformation tool with 3 params and no output schema, the description covers the core purpose and factor semantics. It lacks details on output behavior or potential side effects, but these are less critical for a speed change operation.

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

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

Schema descriptions cover all parameters (100% coverage), but the description adds meaningful semantics for 'factor' with examples. It does not explain output_path beyond the schema, but the factor explanation is a valuable addition.

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: 'Speed up or slow down a video.' It also provides concrete factor examples (2 = twice as fast, 0.5 = half speed) that distinguish it from sibling tools like trim_video or convert_video.

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

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

Usage is implied (when you need to change playback speed), but there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions. It doesn't mention that other tools handle time-based edits differently.

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 adds useful behavioral details: bitrate is computed from duration when a target size is given, and omitting it triggers quality-based compression. However, it does not disclose potential side effects (e.g., overwriting, codec choices, lossy vs. lossless) or limitations, leaving some behavioral burden unmet.

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 grammatically efficient sentences, front-loaded with the core action and followed by necessary parameter details. No wasted words and the structure is highly scannable.

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 3-parameter tool with no output schema, the description covers the core decision (target size vs. quality) and gives sufficient context to invoke correctly. It could mention output_path defaults, but overall it's complete enough for an agent to proceed.

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 baseline is 3. The description goes beyond the schema by explaining how target_size_mb drives bitrate calculation and clarifying the default behavior when omitted. This adds meaningful semantics for parameter usage.

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 ('Shrink') and clearly identifies the resource ('video's file size'), making the tool's purpose immediately obvious. It distinguishes from siblings like 'convert_video' or 'resize_video' by focusing on file-size reduction rather than format or dimensions.

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 ('Shrink a video's file size') but does not explicitly name alternatives or state when not to use it. It gives brief parameter usage context (target size vs. quality-based) but lacks exclusions or comparative guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses key behaviors: clips are normalized to the first clip's resolution/frame rate, and crossfade or hard cuts are applied. It does not mention audio handling or whether inputs are modified, but the most relevant behaviors are covered.

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 long, front-loaded with the core action, and includes a useful detail about normalization without any fluff. 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?

Given the tool's moderate complexity, no output schema, and no annotations, the description is reasonably complete. It explains the concatenation behavior and normalization, which are the most important aspects. It doesn't mention potential side effects like overwriting output, but the schema's output_path description covers where the result goes.

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 100% of parameters with clear descriptions. The description adds only the normalization context, which is not directly tied to a specific parameter. Baseline of 3 is appropriate since the schema already documents parameter meanings.

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 concatenates two or more videos into one file in the order given, with hard cuts or crossfade. It uses a specific verb and resource, and the normalization detail distinguishes it from video stacking or editing tools like stack_videos.

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 (joining videos sequentially) and mentions the order of inputs, but it does not explicitly contrast with alternatives like stack_videos or picture_in_picture. Clear context is provided, but no explicit exclusions or alternative tool names are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool re-encodes and mentions a quality setting, without disclosing potential side effects like overwriting existing files, processing time, whether audio streams are preserved, or the lossy nature of re-encoding. This is a significant transparency gap for a conversion 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 sentence that is front-loaded with the core action ('Re-encode a video') and includes essential details (container formats and quality setting) without any filler. Every word contributes to understanding the tool's purpose, making it highly concise and well-structured.

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

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

The schema provides complete parameter descriptions and the purpose is clear, but the description does not explain behavioral aspects such as what happens if output_path is omitted, whether files are overwritten, or what return value is expected. With no annotations and no output schema, the description alone is not fully complete, though the schema mitigates some gaps by defining all parameters and defaults.

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 descriptions cover 100% of parameters, establishing a baseline of 3. The tool description adds no extra meaning beyond what the schema already provides—it only restates the formats and quality option, which are already documented in the input schema. It does not clarify any relationships between parameters or default output behavior.

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 the specific verb 're-encode' with the resource 'video' and explicitly lists target container formats (mp4, webm, mov, mkv), making the purpose unambiguous. This clearly distinguishes the tool from sibling tools like trim_video or resize_video, which operate on different aspects of video processing.

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

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

The description offers no guidance on when to use this tool versus alternatives such as compress_video or resize_video. It does not mention use cases, exclusions, or provide any comparison, leaving the agent to infer usage solely from the tool name and listed formats.

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 GIF uses an optimized color palette and warns about file size growth, which are behavioral insights beyond the schema. It does not cover all possible side effects (e.g., output overwriting, processing time), but the core behavior is well communicated.

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 only two sentences, with the first sentence front-loading the core function and the second providing a concise, memorable caution. Every word serves a purpose; there is no fluff or redundancy.

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

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

The tool has moderate complexity, but the schema fully documents parameters, and the description covers the main behavior and size implications. Without an output schema, the description sufficiently implies that the tool produces a GIF file. It could mention alternative tools for other conversions, but that is more of a usage guideline than a completeness gap.

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

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

The input schema already provides 100% coverage with descriptions for all six parameters, so the baseline is 3. The description's size warning hints at parameter choices (keep fps/width/duration small) but does not add specific parameter-level semantics beyond what the schema already explains. No additional value is given to individual parameters.

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

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

The description clearly states the tool's function: converting a video (or a section) into an animated GIF with an optimized color palette. This specific verb+resource+output combination distinguishes it from siblings like convert_video and trim_video, which handle generic conversion or trimming without the GIF-specific output.

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 you want a GIF) and includes a practical caution ('Keep GIFs short and small — they get big fast'). However, it does not explicitly compare it to alternatives like convert_video for other formats or trim_video for pure trimming, so guidance on when not to use it is missing.

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 disclosing behavior. It does not mention whether the operation is read-only or mutating, what happens to the original file, any encoding or output dimensions behavior, or error conditions. The only added behavioral hint is the coordinate interpretation, which is more of a parameter detail than a behavioral disclosure.

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 short sentences with no fluff. It leads with the main action, provides a necessary coordinate clarification, and is highly scannable for an AI agent.

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 simplicity of the tool and complete schema descriptions, the description is nearly complete. It lacks an explicit statement that the output will be the cropped region (though this is obvious from the name and output_path parameter), but for a straightforward crop operation with a 100% schema coverage, it is adequately contextualized.

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 a small clarification that x/y is the top-left corner of the region to keep, which reinforces the schema's 'Left edge' and 'Top edge' descriptions. No additional parameter semantics beyond this are provided, but the schema already handles parameter meanings well.

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 function with a specific verb and resource: 'Crop a rectangular region out of the video frame.' It distinguishes itself from siblings like resize_video (which scales the entire frame) by focusing on removing a region, and the detail about x/y as the top-left corner reinforces the crop semantics.

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 this tool (when you need to crop a rectangular region) but provides no explicit guidance on when to prefer it over alternatives such as resize_video or trim_video. There is no mention of exclusions or comparison with 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, the description carries the transparency burden. It discloses that the tool returns a list of cut times and is a detection operation (non-destructive), but does not elaborate on edge cases (e.g., no cuts found) or output format specifics. 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, front-loaded with the core action, followed by the output's use case. Every word earns its place, with no redundant 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?

There is no output schema, so the description must explain return values, which it does ('Returns a list of cut times'). It also connects to sibling tools for a complete workflow. Minor gaps include lack of timestamp format details or handling of edge cases, but overall it is complete for a simple detection 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% and both parameters have descriptive text in the schema (e.g., threshold sensitivity range and default, input_path purpose). The description itself does not add parameter-level detail beyond the schema, so 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 uses a specific verb ('Find') and identifies the resource ('timestamps where the picture changes abruptly'), clearly distinguishing it from siblings like detect_silence and editing tools. It also explains the output's purpose (cut times for trimming/concat), making the tool's 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 states that the returned cut times can be fed into trim_video/concat_videos, giving clear downstream usage context. It does not explicitly mention when not to use it or alternatives, but the intended workflow is clear enough for an AI agent to select it appropriately.

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

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

Since no annotations are provided, the description carries the burden of disclosing behavior. It clearly indicates this is a read-only analysis (find, returns) and describes the output structure (silent ranges and keep-segments). It does not explicitly state 'does not modify the input' but that is strongly implied by the verb 'Find' and the return semantics, making it transparent enough.

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, front-loaded with the main purpose, and includes a practical usage tip. Every word earns its place, with no fluff or repetition of schema 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?

The description covers the core functionality, output, and intended usage, which is sufficient for a tool with 3 parameters and no output schema. It lacks some explicit details like the format of ranges (e.g., start/end times) but these are inferable from the schema and the tool's nature. Overall, it is complete for an agent to select and invoke correctly.

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

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

The input schema has 100% coverage with descriptions for all three parameters (noise_db, input_path, min_duration). The description does not add additional parameter semantics beyond the schema, which is the baseline for full coverage. No extra clarification 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 clearly states the tool's function with a specific verb and resource: 'Find silent stretches in the audio track.' It also specifies the output ('Returns silent ranges plus the non-silent segments to keep') and distinguishes it from sibling tools by mentioning downstream use with trim/concat 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 a clear use case: 'useful for cutting dead air' and even suggests feeding keep-segments into trim_video/concat_videos. It does not explicitly mention when not to use or name alternatives, but the context is sufficiently clear for an agent to 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 provided, the description carries the full burden of behavioral disclosure. It states that it draws on the video and can be time-limited, but does not mention whether the original file is modified, if a new file is written to output_path, or any potential side effects like overwriting. This is a significant gap for a mutation tool with no annotation safety hints.

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, front-loaded with the primary action ('Draw a rectangle outline or filled box'), and every word adds value. There is no fluff or repetition of schema fields, making it highly efficient.

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

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

Given 11 parameters, 100% schema coverage, and no output schema, the description is reasonably complete for selecting the tool, but lacks important operational context like whether it requires output_path, how it interacts with audio or other video properties, or what the visual result looks like beyond a basic rectangle. It is minimal but not fully inadequate for a complex 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?

The schema covers 100% of parameters with descriptions, so the baseline is 3. The description adds minor value by calling out the outline vs. filled box option (which already exists in the 'fill' param) and the time-range limitation (also already in 'start'/'end'). No additional semantic depth 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 the tool's purpose: drawing a rectangle outline or filled box on a video, with specific use cases of highlighting or redacting a region. This distinguishes it from sibling tools like blur_region, which would redact via blurring, and crop_video, which modifies the frame rather than adding an overlay.

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 context for when to use the tool: when the goal is highlighting or redacting a region. However, it does not explicitly mention alternatives or when not to use it, such as 'use blur_region if you need to obscure content without a visible box outline.' This leaves room for ambiguity but gives a solid contextual cue.

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 burden of disclosing behavior. It states the action and supported output formats, but does not mention whether the original video is modified, whether output files are overwritten, or any required libraries/codecs. This is a moderate gap for a file-creation tool.

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

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

The description is a single, focused sentence that front-loads the action and includes the relevant output formats. Every word contributes value; there is no redundant or extraneous information.

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

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

For a simple tool with a fully documented schema and no output schema, the description is sufficient: it explains what the tool does and the available formats. It does not explain return values, but since the tool produces a file, this is not necessary. It slightly lacks guidance on distinguishing from similar audio tools, hence not a 5.

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 all three parameters with descriptions, covering 100% of the schema. The description adds no extra parameter-level detail beyond listing the formats, which mirrors the enum. Since schema coverage is high, a baseline of 3 is appropriate.

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

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

The description uses a specific verb and resource ('Pull the audio track out of a video into its own file'), which clearly distinguishes it from sibling tools like remove_audio or replace_audio. It accurately names the output formats, leaving no ambiguity about what the 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?

The description provides clear context that this tool is for extracting audio into a separate file, but it does not explicitly name alternatives or state when not to use it. The phrase 'into its own file' implies the use case, but lacks explicit exclusions like 'use remove_audio to delete audio track without saving'.

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

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

No annotations are provided, so the description carries the full burden. It states the action and output ('save... as an image') but does not disclose edge cases, side effects, or requirements beyond that. This is adequate but lacks behavioral depth.

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, front-loaded with the primary action, and contains zero filler. 'Good for previews and cover images' adds useful purpose without verbosity.

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 video-processing tool with fully documented parameters and no output schema, the description adequately explains purpose and result. It could mention default behavior or alternatives, but the combination of description and schema is enough 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 description coverage is 100%, so parameters are already fully documented. The description adds no additional parameter semantics, which is acceptable per the baseline of 3 when the schema covers everything.

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: 'Save a single frame of the video as an image (thumbnail/still).' It clearly identifies the tool's function and distinguishes it from siblings like sample_frames by emphasizing 'single frame.'

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 'Good for previews and cover images' provides clear context for when to use the tool. It does not explicitly mention alternatives or when not to use it, but the use cases are sufficient.

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 clearly states the operation is 'Read metadata' and lists the exact outputs, making the non-mutating nature evident. It doesn't elaborate on error handling or return format, but for a read-only inspection tool, this is sufficient.

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 extremely concise: two sentences that immediately state the purpose and enumerate the output fields, followed by a clear usage directive. Every sentence earns its place with zero redundant 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 simplicity (one parameter, no output schema), the description is complete. It specifies the output fields, clarifies the input type, and provides operational context ('use first'). No critical information is missing for an agent to select and use this 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 single parameter input_path is already fully documented in the schema with 'Path to the video or audio file' (100% coverage). The description reiterates that it accepts video or audio files but adds no additional semantic detail beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states the tool reads metadata from a video or audio file and enumerates the specific fields returned (duration, resolution, frame rate, codecs, bitrate, file size). This is a specific verb+resource combination that clearly distinguishes it from the sibling editing tools like trim_video or convert_video.

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

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

The description explicitly says 'Use this first to understand a file before editing it,' providing clear contextual guidance for when to invoke the tool. It does not explicitly exclude alternatives, but since there are no sibling tools that retrieve metadata, this is acceptable.

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 disclosing behavior. It mentions 'Fast — no re-encoding', which is useful, but omits other aspects such as handling audio, output file creation, or potential limitations. The description adds some context but does not fully explain the behavior beyond the basic 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, efficient sentence that immediately states the core function and a key performance characteristic. Every word earns its place, with no filler or redundant information.

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

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

For a simple tool with well-documented parameters, the description is fairly complete. It covers the two operational modes and hints at the output quality. However, it does not mention potential edge cases like mutual exclusivity of 'plays' and 'target_duration' or default behaviors, leaving a small gap.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minimal meaning beyond the schema by mentioning 'a number of times' and 'target duration', which map to the 'plays' and 'target_duration' parameters, but these are already described in the schema. No additional parameter semantics are provided.

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: repeating a video back-to-back either a fixed number of times or until a target duration is reached. It uses specific verbs ('Repeat') and specifies the resource ('video'), effectively distinguishing it from sibling tools like concat_videos or trim_video.

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

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

The description provides clear context for when to use the tool: whenever you need to loop a video. It does not explicitly mention alternatives or exclusions, but the 'back-to-back' phrasing implies concatenation of the same clip, which differentiates it from general concatenation. No unnecessary alternative guidance is given.

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

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

With no annotations provided, the description must carry the full burden. It adds a key behavioral fact ('Video is untouched') and explains the loudness standard, but it does not disclose whether the original file is preserved, what the tool returns, or any potential side effects like quality changes. This is acceptable but not comprehensive.

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, each earning its place. It starts with the action and outcome, then adds a crucial caveat. No filler or redundancy.

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

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

The description covers the core purpose and a key limitation (video untouched), but with no output schema and no annotations, it should mention what the tool returns and whether the input is modified. The output_path parameter hints at a new file, but the description doesn't explicitly confirm non-destructive behavior or result format. There is room for improvement.

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 does not add meaning to input_path or output_path beyond the schema; it only broadly frames the tool's purpose. The baseline of 3 applies 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 clearly states a specific verb ('Normalize') and resource ('audio') with a concrete outcome ('broadcast-standard loudness (EBU R128)'). It also distinguishes the tool from siblings by noting that video is untouched, which is not obvious from the name alone.

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

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

It gives some contextual use cases ('podcast/social-media levels', 'fixes too-quiet or wildly varying audio') but does not explicitly mention when to prefer this over sibling tools like adjust_volume, nor does it state exclusions. The 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 provides critical behavioral details: overlay audio is dropped, main video audio is kept, and overlay disappears when its clip ends. This goes beyond typical expectations and helps the agent understand 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 two sentences, front-loaded with the core purpose, and every sentence adds value (behavioral details). 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?

With no output schema and no annotations, the description covers purpose, key behaviors, and edge cases (overlay ending). It could mention what happens if the overlay is longer than the main video or default dimensions, but schema covers defaults. Overall, it's complete enough for a moderately complex 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 covers all parameters with descriptions (100% coverage), so the description adds minimal extra meaning. The baseline of 3 applies because the schema already does the heavy lifting for parameter semantics.

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 overlays one video on another in a corner, with relatable examples (webcam feed, reaction box). This distinguishes it from sibling tools like add_watermark (image overlay) or stack_videos (side-by-side).

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 this tool via the scenario examples, but does not explicitly contrast with alternatives. It's clear enough for an agent to infer use cases, but lacks explicit 'use instead of' 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 burden. It discloses a key behavioral trait: no re-encoding, implying fast, likely lossless operation. However, it does not disclose what happens when output_path is omitted, whether it overwrites files, or how it handles multiple audio tracks, which are important gaps for a mutation tool.

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

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

The description is two short sentences, with the core purpose front-loaded. The second sentence adds the valuable performance characteristic 'Fast — no re-encoding' without unnecessary verbosity.

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 no output schema, the description covers the essential behavior and a performance trait. It lacks guidance on optional output_path behavior and return values, but the schema and purpose suffice for basic 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% with both parameters described minimally in the schema. The tool description adds no additional parameter-level details, so it relies on the schema, which meets the baseline but doesn't enrich 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 uses a specific verb 'strip' and clearly names the resource 'audio track from a video', with the outcome 'leaving silent video'. This distinguishes it from sibling tools like extract_audio, which preserve audio as a separate file, by clarifying the video remains but is silenced.

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

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

The description implies the tool is for removing audio to produce silent video, but it does not explicitly state when to prefer it over alternatives like extract_audio or replace_audio, nor provide any exclusions. The performance note 'Fast — no re-encoding' hints at a benefit but doesn't guide 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 provided, the description carries the full burden. It discloses an important non-obvious behavior: the output duration follows the shorter of the two sources unless loop_audio is set. This adds value beyond the schema. It doesn't cover every edge case, but the key behavioral trait is disclosed.

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

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

The description is exactly two sentences, front-loaded with the primary action, and includes only relevant details. There is no redundancy or 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 tool with a clear schema and simple operation, the description covers purpose and key behavior. It does not explicitly state whether the input is modified or a new file is created, but the output_path parameter strongly implies a new file. Minor gap, but overall sufficient.

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 a slight nuance by connecting loop_audio to the duration behavior, but this partially overlaps with the schema's description for that parameter. No other parameters receive additional detail beyond what the schema already states.

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 ('Replace') and identifies the exact resources (a video's audio track and a different audio file). It clearly distinguishes this tool from siblings like remove_audio or extract_audio by conveying a swap action.

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 by providing examples ('background music or a voiceover') and implies the use case of swapping out the audio track. It does not explicitly name alternatives or exclusions, but the action is distinct enough to guide the agent.

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

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

Without annotations, the description carries the burden of disclosing side effects or edge cases. It explains the scaling modes and aspect ratio behavior, but does not state what happens if both dimensions are provided (possible distortion) or where the output file is written if output_path is missing. This incomplete transparency is a 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 two short sentences, front-loaded with the core purpose, and every clause adds useful information. No redundancy or 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?

The tool has 5 parameters, no annotations, no output schema, but the schema itself documents each parameter. The description ties together the main scaling modes and aspect ratio logic. However, it omits output behavior and mutual exclusivity details, making it slightly incomplete for a tool with no output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the relationship between width and height (missing one preserves aspect ratio) and framing percent as an alternative to dimensions, which goes 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 'Scale a video to a new resolution' with a specific verb and resource. It distinguishes from siblings like crop_video by focusing on scaling, not cropping. The mention of width/height/percent further clarifies its scope.

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 instructions on how to resize via width/height/percent and notes that the missing dimension preserves aspect ratio, providing contextual usage. However, it does not explicitly mention alternative tools or when not to use this tool, so it stops short of full 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. It reveals a key behavioral trait: 'Buffers the whole clip in memory', and also notes that audio is reversed alongside video. This goes beyond the basic purpose and helps the agent anticipate resource use and suitability. It does not mention other side effects (e.g., metadata loss), but the disclosed behaviors are the most critical.

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 first sentence states the primary purpose, and the second provides a critical caveat with actionable advice. 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?

Given the tool's simplicity (2 params, no output schema), the description covers the essential context: purpose, audio behavior, memory constraint, and usage recommendation. It is complete enough for an agent to decide when to use it and what to expect, though it could optionally note output behavior or lack of metadata preservation for absolute 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 input schema already describes both parameters (input_path and output_path) with 100% coverage. The description does not add additional parameter-specific semantics beyond the schema, so the baseline score of 3 applies. It does mention trimming first, which indirectly relates to input length, but that's more of a usage guideline than a parameter clarification.

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 ('Play the video (and audio) backwards') with a clear resource (the video) and explicitly notes it affects audio as well. This distinguishes it from sibling tools like change_speed or trim_video, which address different transformations.

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: 'best for short clips — trim first for anything over a minute or two' implies when to use and recommends a preceding action (trimming). It does not explicitly name alternative tools or state 'when not to use' beyond the length caveat, but the guidance is actionable and specific.

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 restates the parameter meanings from the schema and does not mention output path defaults when output_path is omitted, whether the input is modified, or any return values/prerequisites.

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 immediately states the tool's purpose without any wasted words. It is front-loaded 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?

The tool is simple, but the description omits critical contextual behavior: output_path is optional in the schema but the description doesn't explain what happens when omitted. It also doesn't clarify behavior when neither degrees nor flip is provided, leaving ambiguity for the agent.

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

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

Schema description coverage is 100%, so all parameters (input_path, output_path, degrees, flip) are already well-documented with names, types, and enums. The description adds little beyond the schema except the 'clockwise' and 'and/or' combination wording, providing no new semantic 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 specifies the exact operation: rotating a video by 90/180/270 degrees clockwise and/or mirroring horizontally or vertically. This clearly distinguishes it from sibling tools like resize_video or crop_video.

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

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

The description implies usage for video orientation and mirroring adjustments, but it provides no explicit guidance on when to choose this tool over alternatives or any exclusions. Given the large sibling set, more explicit usage context would be helpful.

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

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

No annotations exist, so the description carries the responsibility. It discloses key behavior: evenly-spaced sampling, timestamps on tiles, and a single output image. It lacks mention of overwrite semantics or format constraints, but for a media-generation tool, the disclosed behavior is sufficient to set expectations.

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, 28 words, front-loading the action and output. Every word contributes; there is no redundant or filler content.

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 of moderate complexity, the description explains the purpose, the output, and the workflow. A minor gap is the optional output_path not having a default mentioned, and no explicit mention of image format. These are minor and do not undermine task completion.

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 covers all five parameters with descriptions and constraints (count, columns, tile_width, input_path, output_path), so the description is not required to compensate. The description adds no parameter-specific guidance beyond the schema, matching the baseline for 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 specifies a clear verb and resource: 'Tile evenly-spaced frames from across the video into one image'. It also adds distinctive details (timestamp stamping) that separate it from sibling tools like extract_frame or detect_scenes, making the tool's purpose highly 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 explicit context for when to use the tool: 'Use this to SEE what's in a video before deciding how to edit it'. This tells the agent the intended workflow. However, it does not name alternatives or state when not to use it, so it stops short of full exclusion guidance.

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

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

With no annotations, the description carries the full burden. It discloses key behaviors: clips are normalized to the first clip's size, and audio comes from the first clip that has any. This goes beyond the schema and helps set expectations for output characteristics.

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

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

Two sentences, front-loaded with the main purpose, followed by precise behavioral details. No wasted words.

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

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

The description covers the essential behavior for a stacking tool, including layout options, size normalization, and audio selection. Given the small parameter set and full schema coverage, it is sufficiently complete, though it could mention output format or 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%, so the baseline is 3. The description adds slight context about input ordering (first clip as reference) but does not significantly enhance understanding of the parameters beyond the schema's own 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 arranges videos in horizontal, vertical, or grid layouts, using the verb 'stack' implicitly through 'Play videos side by side...'. It differentiates from siblings like concat_videos (sequential) and picture_in_picture (overlay) by focusing on multi-video layouts for comparison.

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 indicates 'great for comparisons', which provides a clear use case. It does not mention when-not-to-use or alternatives, but the context is sufficient for an agent to infer appropriate 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, the description carries the behavioral burden. It explains time formats and the logical relationship between start/end/duration, but does not disclose whether the operation overwrites the original file, whether it re-encodes by default, or other side effects. Some behavior is left to the schema (fast_copy), so the description offers moderate transparency.

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, zero fluff. The main purpose is front-loaded, and the input combination rules are stated compactly and clearly.

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 6 parameters and no output schema, the description covers the core logic well. It does not explain return values, but that's unnecessary without an output schema. It could benefit from noting default re-encoding behavior, but the schema covers fast_copy and output_path, so gaps are 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 baseline is 3. The description adds valuable semantics beyond individual property descriptions by explaining the relationships: start plus either end or duration, and the omit-both case. Time format examples also help agents construct valid values.

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

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

The description uses a specific verb+resource ('Cut a video down to a time range') and clearly distinguishes the tool from siblings like concat_videos or convert_video. It also provides immediate substance on how the cutting is specified (start/end/duration).

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 usage context: how to specify start time and either end or duration, and behavior when omitting both. However, it does not mention any alternatives or when not to use this tool, stopping 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, the description carries the full burden. It discloses key behaviors: images are shown in order, shown for a fixed number of seconds, optionally with a soundtrack, and 'Images are fitted to the first image's size.' This adds important context beyond the schema, though it could be more precise about how fitting works (crop vs stretch).

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, front-loaded with the core purpose, and includes only essential behavioral details. Every sentence earns its place with no redundancy or irrelevant 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 lack of output schema, the description covers the essential purpose, input behavior, and a key constraint (fitting to first image size). It is complete enough for an agent to invoke correctly, though it could mention the output format (though that is in the schema) or edge-case behaviors.

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 provides 100% coverage for parameter descriptions, so the baseline is 3. The tool description does not add additional parameter-level meaning beyond what the schema already states; for example, audio_path is already described as 'Optional soundtrack (trimmed to the slideshow length)' in the schema.

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

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

The description clearly states 'Build a video from a list of images' with specific details about ordering, fixed duration, and optional soundtrack. This distinguishes it from siblings like create_gif or concat_videos, as it is specifically for creating a video from images.

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 context for when to use the tool (creating a slideshow from images) and implies the use case. It does not explicitly name alternatives or exclusions, but given the sibling tools, there is no direct alternative for this function, so the guidance is clear enough.

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