kinocut

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

With no annotations, the description carries the full behavioral burden. It discloses useful details such as WAV-only input, volume multiplier range 0-1, loop default false, and a success/output_path return shape, but it omits overwrite safety behavior, error conditions, and what happens when duration exceeds or truncates track length.

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 definition is front-loaded and organized with Args and Returns sections. There is minor redundancy between the opening two sentences, but overall it is efficient and easy to scan.

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

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

Given a nested tracks argument and an existing output schema, the description provides enough core invocation detail for an agent to construct a valid call. The main omission is the optional overwrite parameter and its mutation-safety implications, though the schema documents that field.

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 low at 25%, and the schema defines tracks only as a generic array of objects. The description compensates by documenting nested track fields (file, volume, start, loop), as well as duration and output_path. The overwrite parameter is not mentioned in the description, but its semantics are supplied by the schema.

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

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

The description states a clear verb and resource: "Layer multiple audio tracks with volume mixing" and "Mix multiple WAV files together." It does not explicitly distinguish itself from nearby siblings such as audio_sequence, video_mix_audio, or sound_mix_render, so it is clear but lacks sibling 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?

It describes what the tool does but gives no explicit guidance on when to use it versus alternatives. There are many audio/mixing siblings, and the description neither names them nor states exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden. It does disclose the WAV-only format constraint and the return shape (success flag + output_path), which is real value. However, it says nothing about what happens when output_path already exists, that overwriting is gated behind a separate flag, or how partial/effect failures are reported (all-or-nothing vs. best effort).

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

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

Front-loaded with the action and resource, then parameters, then return value. The Google-style Args/Returns scaffolding is slightly verbose given an output schema already exists, but no sentence is wasted.

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

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

An output schema exists, so the Returns block is redundant rather than necessary. For a write-producing tool with zero annotations, the description is not quite complete: overwrite semantics, error behavior, and the concrete set of supported effect types and their parameters remain unstated, which matters because the effects array accepts arbitrary objects.

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

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

Schema coverage is only 25%, so the description must compensate, and it largely does: it specifies that input_path/output_path are absolute paths and that input must be WAV, and it sketches the effects list structure with a type discriminator plus per-type extra params. The main gap is the undocumented `overwrite` parameter, which the description never mentions (only the schema covers it), and the open-ended 'additional params per effect type' leaves effect options underspecified.

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

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

The first sentence gives a specific verb+resource (apply an effects chain to a WAV file) and the second clarifies the chain concept with examples (reverb, filtering, normalization). It is clearly distinguishable from neighbors such as video_normalize_audio or audio_preset, though it never names or contrasts those siblings explicitly.

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

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

Usage is only implied: the reader infers you use this when you want multiple audio effects applied in one pass to a WAV file. There is no statement of when NOT to use it, no mention of alternatives (e.g. video_normalize_audio for a single normalize pass), and no prerequisites such as supported sample rates or channel layouts.

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 usefully discloses that the tool writes a WAV file to a path and returns a dict with success status and output_path, plus defaults for pitch/duration/intensity. It does not explain the overwrite safety behavior, what happens if an existing file is present, or what occurs when output_path is omitted (nullable in schema), leaving meaningful mutation-side behavior 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?

Front-loads purpose, then provides the preset catalog as a scannable categorized list, followed by conventional Args and Returns sections. Every block earns its place; the formatting is dense but appropriate. Slightly verbose in restating defaults that also appear in the schema.

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

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

With an output schema present, return explanation is optional and the brief note is harmless. Preset naming, pitch values, and intensity range are all resolved in-description, which is exactly what a low-coverage schema needs. The only material omission is overwrite/file-collision behavior, a moderate but not crippling gap for a local file-writing tool.

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

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

Schema description coverage is only 17%, so the description must compensate, and it largely does: it supplies the full enumerated preset catalog (the schema has no enum), the allowed pitch values low/mid/high (also not in schema), the 0-1 range for intensity, and that duration is in seconds and output_path must be absolute. Only the overwrite parameter is undocumented in the description (covered by the schema itself).

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

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

States a specific verb and resource: 'Generate preset sound design elements,' immediately clarified as 'Pre-configured sound effects for common use cases.' The word 'preset' and the enumerated catalog of ready-made effects distinguish it conceptually from generative siblings like audio_synthesize or audio_compose, though no sibling is named explicitly.

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

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

'Pre-configured sound effects for common use cases. No external audio files needed' implies when to reach for it (ready-made SFX, no source assets), which is real context. However, it never states when NOT to use it or routes the agent to an alternative such as audio_synthesize or audio_effects, so selection guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that the tool writes a WAV file to an absolute path and returns a success dict, which is real behavioral value. However, it says nothing about what happens to existing files at that path (the 'overwrite' flag exists in the schema but the description never explains the default-deny behavior the schema implies), nor about failure modes or cost of large sequences.

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

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

Front-loaded with the operation, then a scannable Args/Returns breakdown that earns its space for a nested-array parameter. The only waste is the second sentence, which restates the first ('layered audio track from multiple timed sound events' vs 'compose multiple audio events into a timed sequence').

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 write tool with an output schema (so return values need not be explained) and no annotations, the event schema is well specified. Missing pieces that an agent would want: overwrite/refusal behavior on existing files, what happens with overlapping events, and why this exists alongside audio_compose and audio_synthesize.

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

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

Schema coverage is only 33%, so the description must compensate, and it largely does: it fully enumerates the sequence item fields (type, at, duration, freq/frequency, name, volume, waveform) that the schema leaves as an opaque object with additionalProperties. It also clarifies output_path must be absolute and WAV. It does not explain the substantive 'overwrite' parameter, which is the one parameter the schema actually documents, so the gap is mostly covered elsewhere.

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

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

States a specific verb and resource: 'Compose multiple audio events into a timed sequence' and 'Creates a layered audio track from multiple timed sound events.' That is clear enough to know it builds a timed multi-event audio file, but it offers no differentiation from the many audio siblings (audio_compose, audio_synthesize, audio_preset, video_audio_bed) whose names suggest overlapping territory.

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

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

There is no statement of when to use this tool versus audio_compose, audio_synthesize, audio_preset, or the sound_mix_render family, all of which could plausibly be selected for audio creation. No prerequisites, no exclusions, no context beyond the mechanics of the call itself.

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

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

With no annotations, the description carries the full burden: it discloses the file-creation side effect and that a success status is returned. However, it never says what happens if output_path already exists or that an overwrite flag is required, nor does it mention validation/error modes for bad paths or frequencies.

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

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

Front-loaded purpose sentence followed by an Args/Returns block; every arg line conveys usable defaults or valid values. Slight padding in the repeated 'defaults' phrasing but no wasted structure.

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

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

For a file-writing tool with zero annotations, it covers purpose, defaults, the valid waveform set, the effects schema shape, and the return shape (redundant with the output schema but harmless). The one meaningful gap is overwrite/collision behavior, which the schema documents only in passing.

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?

Six of seven parameters gain real meaning here, but one silent behavior matters: the description omits the effects keys it does not cover and never mentions overwrite. Effects values are left underspecified and there is no indication of what happens on an existing path.

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

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

States a specific verb and resource ('Generate audio procedurally', 'Creates WAV files from scratch using mathematical waveforms') and the mechanism clarifies it is not a file-source tool. It implies the distinction from composing/sequencing siblings ('No external audio files needed') but never names them, so sibling differentiation stays implicit.

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

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

The phrase 'No external audio files needed' implies when to use it (synthesizing tones from scratch rather than mixing existing media), but there is no explicit when-to-use/when-not statement and no reference to alternatives like audio_compose, audio_sequence, or audio_preset.

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 does disclose the return shape ('Dict with success status and output_path') and the effect's definition. But it never mentions the destructive-adjacent 'overwrite' behavior, whether the operation re-encodes/reduces quality, or processing cost — gaps for a video-mutating tool.

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

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

Front-loaded one-liner followed by a short effect description and conventional Args/Returns blocks. Slight waste in restating param types already visible in the schema, but overall tight and 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 5-param media-mutation tool with no annotations, the description supplies purpose, the four creative parameters, and the return contract; an output schema exists so the Returns section is a minor redundancy. The one meaningful hole is the unmentioned 'overwrite' flag and any note on quality loss or file handling.

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

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

Schema coverage is only 20%, and the description compensates well for input_path, output_path, intensity (pixel offset, default 2.0) and angle (degrees, default 0 = horizontal) — semantics the schema does not supply. It omits 'overwrite' entirely, which is the one parameter the schema does document, so nothing is double-counted and the coverage gap is largely closed.

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

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

States a specific verb and resource: 'Apply chromatic aberration - RGB channel separation,' plus a one-line characterization of the visual result. It's clear what the tool does, though it never distinguishes itself from nearby siblings like glitch_rgb_shift or glitch_cmyk_split, which sound superficially similar.

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

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

There is no when-to-use/when-not-to-use guidance, no prerequisites, and no mention of alternative tools. The aesthetic phrasing ('trendy... popular in tech/glitch aesthetics') is descriptive flavor, not routing guidance an agent can act on.

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

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

With no annotations, the description carries the full behavioral burden: it does disclose that a new video is produced at output_path and that a success/output_path dict is returned, which is real value. However, it never mentions that output_path may already exist and that overwrite must be set to replace media (the schema's only documented parameter), nor any cost, performance, or failure behavior for a file-writing operation.

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

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

Two-sentence summary is front-loaded and the args/returns listing is scannable with no filler. The Returns block partially duplicates the output schema, a minor redundancy.

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

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

For a 6-parameter video mutation tool with an output schema and no annotations, the definition covers purpose, all visual parameters, and the return shape well. It is short only on the file-safety/overwrite semantics and on interaction with audio or existing output files.

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 17%, so the description must compensate, and it largely does: it gives units and ranges for intensity (0-1), radius (pixels), threshold (brightness 0-1) plus defaults, and clarifies both paths must be absolute. The one gap is overwrite, which the description omits entirely even though the schema documents it, leaving an agent to discover the overwrite-protection behavior only 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 names a specific effect ('bloom/glow for highlights') and explains its visual result ('soft glow around bright areas'), which is enough to distinguish it from effect_vignette, effect_noise or glitch_* siblings by effect type. It does not explicitly contrast with any sibling, so it stops short of a 5.

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

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

There is no guidance on when to choose glow over alternatives such as video_filter, effect_chromatic_aberration, or still_grade, and no stated preconditions (video format, codec, whether audio is preserved). The intended use is only implied by the effect name.

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

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

No annotations exist, so the description carries the full behavioral burden. It usefully discloses defaults (intensity 0.05, mode film, animated true) and the per-frame behavior implied by 'animated', but says nothing about overwrite semantics, cost/performance, or whether the output codec/resolution is preserved. The mutation and overwrite risk is only covered incidentally by the schema.

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

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

Front-loaded one-liner followed by a structured Args list that is easy to scan. The second sentence slightly restates the first ('adds texture noise' vs 'apply film grain or digital noise') but earns its place by naming the aesthetic use case.

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

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

An output schema exists, so the brief Returns note is optional garnish. With all meaningful parameters except overwrite explained and output shape known, an agent has enough to invoke it correctly; only the overwrite/mutation risk and sibling disambiguation are thin.

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

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

Schema coverage is only 17% (just the overwrite field), so the description does real work: it documents intensity as a 0-1 range with default 0.05, supplies the otherwise-missing mode values (film, digital, color), and explains animated as per-frame variation. Only overwrite is left unaddressed in prose, and that one is documented in the schema itself.

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

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

States a specific verb and resource: 'Apply film grain or digital noise' to video, with the aesthetic intent (vintage/lo-fi) spelled out. It never names or distinguishes itself from the many sibling effect_* / glitch_* tools, so an agent must infer that this is the texture-noise one.

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

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

The phrase 'for vintage or lo-fi aesthetics' implies when to reach for it, but there is no explicit when-not guidance, no mention of prerequisites (e.g., when to combine with effect_scanlines or effect_vignette), and no alternatives named.

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

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

With no annotations, the description carries the full behavioral burden. It says the tool applies an effect and returns a success status plus output_path, but does not disclose overwrite behavior, whether the input is modified, or how existing output is handled.

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

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

The description is front-loaded and efficiently organized into purpose, Args, and Returns. The Args section repeats some schema defaults, but it remains readable and contextual rather than bloated.

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

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

The description covers the effect, most parameters, and the return shape, and an output schema exists. However, for a mutation tool with no annotations, it should more clearly state output overwrite and safety behavior to be fully complete.

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

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

Schema description coverage is low at 17%, but the description compensates well by documenting five of six parameters with meaning, ranges, and defaults. The only notable omission is overwrite, which is documented in the schema but not in the description.

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

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

The description clearly states a specific verb and resource: applying a CRT-style scanlines overlay with optional flicker. It is distinguishable from most siblings, but it does not explicitly differentiate itself from the closely related glitch_scanline_jitter tool.

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

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

The description implies the visual use case but gives no explicit guidance on when to use this effect versus alternatives such as glitch_scanline_jitter, effect_vignette, or other glitch/effect tools. It also omits prerequisites or exclusions.

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

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

No annotations exist, so the description carries the full burden. It does disclose the return shape (dict with success status and output_path) and the numeric ranges/defaults of the effect parameters, but it never mentions overwrite behavior, file replacement risk, or the fact that output_path is optional — the 'overwrite' parameter is only explained in the schema, and the destructive-write aspect is unaddressed.

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

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

It is front-loaded with a one-line definition before the elaboration, then a compact args/returns block. The only mild waste is restating schema defaults (0.5, 0.8), but that is minor and aids scanning.

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

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

The tool is a simple single-purpose video filter and the description covers what it does, how each shaping parameter behaves, and the return contract — more than sufficient despite the presence of an output schema. It falls short only on overwrite/output_path semantics, which matter because this writes a new media file.

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

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

Schema description coverage is only 17% (just 'overwrite'), so the description must compensate, and it does: intensity, radius, and smoothness all get meaning plus 0-1 ranges, and input_path/output_path are described as absolute paths. The one gap is that 'overwrite' and the optionality of output_path are not covered in the description text.

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

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

The description opens with a specific verb and resource ("Apply vignette effect") and immediately explains what that means, "creates a darkened border effect that draws attention to the center of the frame." An agent can distinguish this from effect_glow or effect_noise without opening the schema, though it never names those siblings explicitly.

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

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

Usage is only implied through the aesthetic intent ("draws attention to the center of the frame"), which hints at when the effect is appropriate. There is no explicit when-to-use, when-not-to-use, or alternative (e.g. effect_glow, video_filter) guidance, and no prerequisites are stated.

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

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

With no annotations, the description carries the full behavioral burden. It usefully explains the visual transformation and mentions the return payload, but it omits operational behavior such as overwrite handling, whether existing output is replaced, and file-safety expectations, even though those matter for a processing 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 front-loaded with purpose and effect mechanics, then moves into parameters and return value in a predictable structure. It is efficient, though it repeats schema defaults and includes a return sentence that is redundant given the output schema.

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

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

For a single-effect video tool with an output schema and a schema-described overwrite flag, the definition is largely complete enough to invoke correctly. The main missing context is sibling differentiation and explicit overwrite/file-safety guidance, but the core effect and key parameter meanings are covered.

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

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

Schema description coverage is only 17%, so the description must compensate, and it does for five of six parameters: input/output paths, amount in pixels, angle in degrees, and noise on a 0-1 scale. It omits the overwrite parameter, but the schema itself provides a description for overwrite, limiting the gap.

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

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

The description states a specific verb and effect: it applies a CMYK split glitch by shifting RGB channels at 90-degree intervals to simulate four-plate registration errors. That is clearer than a generic glitch tool, but it does not explicitly differentiate this from close siblings such as glitch_rgb_shift or transition_glitch.

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

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

Usage is implied by the effect description: an agent can infer it should use this when it wants a CMYK split / print-registration glitch look. However, the description gives no explicit when-to-use guidance, no exclusions, and no recommendation among the many glitch and transition siblings.

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

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

With no annotations, the description carries the burden and does add real value by explaining the drift-then-reset artifact model, so the agent knows the visual behavior. It omits operational context: that overwriting existing media requires the separate overwrite flag, that encoding happens (re-encode implied), and any cost/duration 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?

Front-loaded purpose sentence, one clarifying sentence on the mechanics, then compact Args/Returns blocks. Defaults are restated from the schema but that repetition is cheap and aids scanning.

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

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

The output schema plus the Returns line cover the response shape, and the four core params are explained. Still missing for a media-mutation tool: the overwrite-safety rule, accepted input formats/containers, and whether output_path may be omitted and defaulted.

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

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

Schema coverage is only 20% (only overwrite is documented), but the description compensates well by explaining input_path, output_path, drift as max displacement in pixels, and iframe_interval as the reset cadence, including defaults. Only overwrite is left undocumented in prose, though the schema covers 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?

"Apply datamoshing glitch effect" is a specific verb+resource, and the follow-up sentence explains the P-frame displacement mechanic, which distinguishes it from generic siblings like transition_glitch or glitch_macroblocking. It never explicitly names an alternative, so it stops short of a true 5.

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

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

The description says what the effect does but gives no guidance on when to pick it over the nearby glitch_* family (rgb_shift, scanline_jitter, screen_tearing, macroblocking) or what source footage suits it. No prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the full burden. It discloses the Node.js + GPU requirement and explains the algorithmic effect, which is useful. However, it omits mutating behavior details (e.g., overwrite protection, error handling, or processing side effects) that an agent would need for safe invocation.

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

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

The description is front-loaded with the core effect and prerequisite, followed by a parameter list and return note. It is appropriately sized for a seven-parameter tool and avoids filler, though the 'Args:'/'Returns:' docstring style adds slight 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?

Given an effect tool with seven parameters, no annotations, and an output schema, the description covers the effect, prerequisite, parameter meanings, and return format. It is nearly complete; only the overwrite safety behavior is not mentioned, but that is documented in the schema.

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

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

Schema description coverage is only 14%, so the description must compensate. It documents six of seven parameters with clear semantics (depth extraction intensity, pixel spread, point size, threshold range), adding substantial meaning beyond the schema. The only gap is the overwrite parameter, which is already described 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 a specific verb ('Apply') and resource ('depth-based point splatting effect') and explains the visual result. However, it does not explicitly differentiate this tool from the closely related sibling 'glitch_point_cloud', which could cause 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 includes an environment prerequisite ('requires Node.js + GPU') but provides no guidance on when to choose this effect over alternatives like glitch_point_cloud or other glitch tools. There are no when-to-use or when-not-to-use statements.

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

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

With no annotations, the description carries the full burden. It usefully discloses the Node.js/GPU dependency and the return shape, which adds value. However, it is silent on mutation safety — notably the overwrite/protection policy documented only in the schema — and says nothing about processing cost or failure modes for a GPU-bound 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?

Front-loaded summary sentence, then a tight two-line explanation of the effect, then structured Args/Returns. Every line earns its place with no filler.

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

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

Arguments and return behavior are largely covered, and an output schema exists so the Returns section is a nice redundancy rather than a necessity. Only the overwrite semantics and GPU failure handling are absent, which are minor gaps for a well-documented render 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 low (14%), so the description must compensate, and it does: it documents six parameters with meaning and defaults (feedback_mix, scale, rotation, decay, input_path, output_path). Only 'overwrite' is left unaddressed, and the schema already describes that one.

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

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

States a specific verb and resource ('Apply digital feedback glitch effect') and explains the mechanism (iterative frame feedback with scale/rotation, ghostly trails). This is concrete enough to distinguish it from generic glitch siblings, though it never names an alternative explicitly.

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

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

The 'requires Node.js + GPU' line is a real prerequisite that helps an agent decide whether it can run at all. But there is no guidance on when to pick this over the many other glitch tools (glitch_rgb_shift, glitch_vhs_tracking, etc.), so usage is only implicitly derivable from the effect description.

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

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

With no annotations, the description carries the full burden. It discloses the processing approach and the return shape (success flag + output_path), which is useful, but says nothing about overwrite semantics, whether the input is modified, cost/perf, or failure modes for an inherently destructive-looking media write.

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

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

Front-loaded one-line purpose followed by a short mechanism sentence and a compact Args/Returns block. No filler; every line conveys usable 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?

Adequate for a media-mutating effect: parameters and return value are covered and an output schema exists. But with zero annotations and a low schema coverage, omitting file-overwrite behavior and side effects leaves a meaningful gap for a write operation.

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

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

Schema coverage is only 17%, so the description must compensate — and it does, documenting 5 of 6 params with meaning and defaults (block size in pixels, intensity as blend with original 0-1, color reduction level). Only 'overwrite' is undocumented in the description, though the schema covers 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?

Names a specific action and effect ('Apply macroblocking glitch effect') and explains the mechanism: downscale/upscale blocky pixelation plus color posterization. That mechanism effectively separates it from neighbors like glitch_rgb_shift or transition_pixelate, though no sibling is named explicitly.

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

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

There is no statement of when to choose this effect over the many other glitch/transition tools, nor any prerequisites or exclusions. Only implied usage ('use this to make a macroblocking glitch') is present.

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 and does disclose the GPU/Node.js requirement, the visual transformation, and a basic return shape. It does not explain overwrite behavior, performance characteristics, or whether the input is modified, leaving meaningful gaps for a video 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 front-loaded and organized into Args and Returns sections, making it easy to scan. The Returns section is somewhat redundant because an output schema exists, but it is short and does not significantly dilute the useful 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 moderately complex GPU-based effect with seven parameters and an output schema, the description provides enough detail to invoke the tool correctly, including parameter semantics and prerequisites. The missing pieces are mainly overwrite behavior and sibling differentiation, which are secondary to calling the tool.

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

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

Schema description coverage is only 14%, so the description must compensate, and it does: it documents input/output paths and gives meaning, ranges, units, and defaults for density, point_size, rotation, and depth. It misses the overwrite parameter, but that parameter is already described 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 names a specific verb and effect: apply a point cloud rendering effect, and explains the visual result as scattered points in a 3D-rotated grid with depth displacement. It is clear what the tool does, but it does not distinguish this effect from nearby siblings such as glitch_depth_splatting or other glitch 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?

Usage is implied by the effect name and visual description, and the Node.js + GPU requirement gives an important operational precondition. However, there is no explicit guidance on when to choose this over alternative glitch effects or when not to use it.

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

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

With no annotations, the description carries the full burden. It does disclose the visual behavior and the optional noise augmentation, and mentions the return shape. It omits important behavioral facts: the destructive-write protection implied by the 'overwrite' parameter, what happens when output_path is omitted (nullable, default null), and any processing cost or format constraints.

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

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

Front-loaded summary sentence followed by a short behavioral clause and a compact Args/Returns block. Every line adds information, and there is no filler.

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

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

For a mutation tool with no annotations and 6 parameters, the description covers the core effect and most parameters but leaves gaps: overwrite/file-protection semantics, the default output location when output_path is null, and any format or codec handling. The output schema means return values need not be explained, so the 'Returns' line is minor redundancy rather than a gap.

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

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

Schema description coverage is only 17%, so the description must compensate, and it largely does: it gives units and defaults for amount (pixels, 10.0), angle (degrees, 0 = horizontal), and the 0-1 range for noise. It does not cover the 'overwrite' parameter at all, and describes output_path as an absolute path without noting it is optional/nullable and what the default means.

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

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

States a specific verb and effect: 'Apply RGB channel shift glitch effect', then explains the visual result (red and blue channels shifted in opposite directions for chromatic split). A reader knows exactly what it does. However, it does not distinguish itself from closely related siblings such as effect_chromatic_aberration, glitch_cmyk_split, or transition_glitch, which an agent could easily confuse it with.

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

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

No guidance on when to choose this over effect_chromatic_aberration or glitch_cmyk_split, which produce visually similar channel-split results, nor any prerequisites (supported formats, whether input must be video). The only usage signal is the optional noise flag, which is a parameter trait rather than routing advice.

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

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

With no annotations, the description carries the full burden. It discloses the effect, parameter defaults, and return shape, but it does not explain overwrite protection, whether output_path is required, failure behavior, or processing implications 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?

Front-loaded with the core effect and visual result, followed by compact Args and Returns sections. Every sentence adds useful context without filler or repetition.

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

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

An output schema exists, so return values do not need extensive explanation. Most parameters are documented and the effect is clear, but the missing overwrite discussion and lack of sibling routing leave minor gaps for a 7-parameter mutation tool.

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

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

Schema description coverage is only 14%, so the description must compensate. It explains six of seven parameters with meanings and defaults (jitter_amount, frequency, speed, row_height, input_path, output_path), though it omits overwrite, which is documented in the schema itself.

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

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

States a specific verb and effect (scanline jitter glitch) and explains the visual mechanism: random horizontal row displacement for a CRT malfunction look. It is clear on its own, but does not explicitly distinguish itself from the many sibling glitch effects.

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 via 'CRT malfunction look,' giving a creative context, but it provides no explicit when-to-use guidance, exclusions, or alternatives among the numerous glitch siblings (e.g., glitch_screen_tearing, glitch_vhs_tracking).

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

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

With no annotations, the description carries full behavioral burden; it does describe the animation semantics (tear bands at varying Y positions, horizontal offset over time) and defaults, which is useful. However it is silent on overwrite/protection semantics, whether audio is preserved, and any side effects of writing to output_path, leaving meaningful 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?

Front-loaded with the effect and its visual behavior, then Args/Returns in a conventional structured form. The Returns section is largely redundant given the output schema exists, but overall it is compact and wastes little space.

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

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

An output schema exists, so the description needn't explain return shape beyond its one line; combined with documented parameters and behavior, an agent has enough to invoke it correctly.

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

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

Schema description coverage is only 17%, so the description meaningfully compensates: it explains units and defaults for tear_count, offset_range (pixels), and speed, and clarifies input/output paths as absolute video paths. It omits the `overwrite` parameter entirely and does not clarify that output_path is optional/nullable (auto-derived), which is a gap given low schema coverage.

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

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

States a specific verb and effect ('Apply screen tearing glitch effect') and elaborates with a concrete visual description of horizontal tear bands shifting left/right. It is distinguishable from siblings like glitch_scanline_jitter or glitch_rgb_shift by the visual mechanism, but it never explicitly contrasts itself with them.

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

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

No guidance on when to choose this glitch effect versus the many sibling glitch/transition tools, nor any stated prerequisites (e.g., input codec support, processing expectations). The agent must infer usage entirely from the effect name.

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

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

With no annotations, the description carries the full burden; it does disclose the runtime requirement (Node.js + GPU), the visual effect semantics, and the shape of the return value. It leaves out failure behavior, cost/performance implications of the 120-frame depth, and overwrite semantics (left to the schema). 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?

Front-loaded with the effect and its visual rationale, then clean Args/Returns blocks. Efficient overall, though the slit-scan photography simile sentence is slightly decorative rather than operational.

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 an output schema exists, the Returns line is a harmless restatement. The description supplies the prerequisite, the parameter value maps, and the effect intent — enough for an agent to invoke it correctly; only edge-case behavior (overwrite conflicts, GPU-absence failure) is unaddressed.

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

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

Schema coverage is only 20%, but the description compensates strongly: it documents input_path/output_path as absolute paths, gives depth's range (1-120) and default (30), and crucially decodes direction's four numeric values (0=top-bottom … 3=right-left) that the schema exposes with no enums. Only overwrite is left to the schema, where it is already documented.

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

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

States a specific verb and effect ('Apply slit-scan temporal displacement effect') and explains the mechanism (each row/column sampled from a different past frame), which is enough to distinguish it from neighbouring glitch siblings like glitch_scanline_jitter or glitch_screen_tearing. It doesn't explicitly compare itself to those siblings, but the effect description is distinctive.

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 prerequisite 'requires Node.js + GPU' is a useful gating constraint for choosing this tool, but there is no explicit when-to-use/when-not guidance or naming of the alternative glitch tools an agent could pick instead. 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?

With no annotations, the description carries the full behavioral burden. It usefully explains the noise model and return shape, but it omits write/overwrite semantics, whether existing outputs are replaced, and safety context around the mutation—important for a video-writing 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 front-loaded with the effect and algorithm, then uses structured Args/Returns sections. It is appropriately sized for a tool with several tuning parameters, with little waste.

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

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

For a moderately parameterized video effect tool, the description gives enough to invoke it correctly: required input path, output path, and tuning parameters with defaults. The main omissions are overwrite behavior and sibling differentiation, but an output schema exists so return values need not be exhaustively explained.

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 very low (14%), so the description must compensate. It documents six of the seven parameters with meaningful units and defaults (pixels, frequency, speed, octave range) and specifies that input/output paths should be absolute, though it does not mention the overwrite parameter.

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

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

The description states a specific verb and effect: 'Apply turbulent displacement glitch effect', and explains the algorithm briefly. It is clear what the tool does, but it does not distinguish it from the many sibling glitch/transition tools such as glitch_rgb_shift or transition_glitch.

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

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

There is no guidance on when to use this tool versus the numerous sibling glitch effects or when not to use it. The description only describes the effect and parameters, leaving selection entirely to inference.

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

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

No annotations are provided, so the description carries the full burden. It discloses the visual behavior of the effect and describes the return shape, but omits whether it re-encodes or destroys the source, codec/format constraints, or how it handles an existing output file (the overwrite flag lives only in the schema).

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

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

Front-loaded with a one-line purpose, followed by a compact Args block and a brief Returns line. Every line earns its place, with only minor redundancy between the first two sentences.

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

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

For a 7-parameter effect tool with an output schema present, the description covers nearly all parameters and the effect semantics. The remaining gaps are the undocumented overwrite behavior and the lack of when-to-use routing among numerous sibling glitch tools.

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

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

Schema coverage is only 14%, so the description must compensate, and it largely does: it documents tracking (0-1), noise_amount (0-1), color_bleed (pixel shift), roll_speed, input_path, and output_path with meanings and defaults. The gap is overwrite, which the description never mentions even though it gates overwriting existing media.

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

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

States a specific verb ('Apply') and resource ('VHS tracking error glitch effect') plus a concrete visual breakdown (color bleed, rolling bands, analog noise). An agent can distinguish this from glitch_scanline_jitter or glitch_screen_tearing by the effect described, though it never explicitly names the alternatives it differs from.

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 what the effect looks like but not when to choose it over the many sibling glitch tools (glitch_rgb_shift, transition_glitch, effect_noise). No prerequisites, no exclusions, no guidance on input requirements beyond 'absolute path'.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose what happens to existing files or media during installation, how overwrite protection works, what no_clipboard changes, or whether the operation is idempotent.

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

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

The description is short and front-loads the core purpose before listing arguments. The Args block is efficient, though it does not fully cover the tool's optional parameters.

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

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

For a mutation tool with no annotations, the description is incomplete: it lacks when-to-use guidance, prerequisites, and behavioral details about overwriting and clipboard handling. Since an output schema exists, return-value explanation is not required, but the remaining gaps are substantial.

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

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

Schema description coverage is only 25%, and the description usefully documents the two required parameters with examples for block_name. However, it leaves no_clipboard undocumented, and overwrite semantics are covered only by the schema rather than the description.

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

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

The description states a specific verb and resource: installing a block from the Hyperframes catalog. It is clear what the tool does, though it does not explicitly differentiate itself from sibling tools such as hyperframes_catalog.

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

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

The description gives no guidance on when to use this tool versus hyperframes_catalog, hyperframes_init, or other Hyperframes tools. It also omits prerequisites, such as whether the project must already be initialized.

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

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

With no annotations, the description carries the full behavioral burden and does not meet it: it doesn't say whether benchmarking performs real renders (costly/slow), whether it writes media to disk, or that output_path/overwrite govern file creation. Only the schema hints at file output via the overwrite parameter.

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity is partly the cause of the missing guidance noted elsewhere.

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

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

For a 5-parameter tool with no annotations and thin schema coverage, the description omits what a benchmark run entails, what the runs default means, and how output is produced. The output schema covers return values, but the invocation-side context remains thin.

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

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

Schema description coverage is only 20% (just overwrite), and the description adds no meaning for runs, output_path, json_output, or project_path. With four of five parameters undocumented, the description fails to compensate for the coverage gap.

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

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

States a specific verb (benchmark) and resource (Hyperframes render) plus the measured dimensions (speed and file size), so the purpose is unmistakable. It does not, however, distinguish itself from close siblings like hyperframes_render or video_benchmark_run.

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

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

There is no guidance on when to run a benchmark versus a normal render, what prerequisites exist (e.g., a valid project or built composition), or how it relates to hyperframes_render / video_benchmark_run. The agent must infer usage entirely.

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

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

With no annotations, the description carries the full burden and discloses meaningful behavior: it downloads the requested website and assets, suppresses provider captions, and enforces a privacy/security posture via --skip-vision so inherited credentials cannot trigger upstream image uploads. It omits operational behavior such as overwrite semantics, timeout handling, or screenshot limits, but the security and side-effect disclosure is substantial.

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

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

The purpose is front-loaded in the first sentence, followed by asset-download context, a security note, and a practical follow-up instruction. It is compact and mostly earns its space, though the internal reference to 'Kinocut passes --skip-vision' is implementation jargon that may be less actionable than plain language.

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 high-level capture behavior and an important security constraint, and an output schema exists so return values need not be explained. However, for a six-parameter tool with only 17% schema description coverage, the description does not sufficiently explain key parameters or when to choose this capture tool over sibling Hyperframes tools.

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

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

Schema description coverage is only 17% and the description does not explain url, output, timeout_ms, skip_assets, or max_screenshots. The phrase 'Downloads the requested website and assets' loosely implies what skip_assets controls, but the description leaves most parameters undocumented, failing to compensate for the low schema coverage.

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

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

The description states a specific verb and resource: 'Capture a website as editable Hyperframes components without provider captions.' This clearly identifies the operation and adds a distinguishing constraint (no provider captions), though it does not explicitly contrast with close siblings like hyperframes_snapshot or hyperframes_still.

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

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

Usage is implied by the capture purpose, and the final sentence gives a concrete follow-up instruction: 'Inspect retained images with your host's configured model instead.' However, it does not say when to use this tool versus alternatives such as hyperframes_snapshot, hyperframes_still, or hyperframes_compositions, nor does it state any exclusions.

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

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

No annotations are provided, so the description carries the full burden. 'Browse' weakly implies a read operation, but it does not state read-only behavior, pagination, permissions, or why a mutation-oriented 'overwrite' parameter exists on a browse tool — a notable unexplained behavior.

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

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

The single sentence is front-loaded and free of waste, but it is tersely under-specified rather than optimally concise for a 3-parameter tool. It earns its place as a purpose statement but leaves too much unsaid.

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

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

An output schema exists, so return values need not be explained. But with no annotations, two undocumented filtering parameters, and an unexplained overwrite flag, the description is not complete enough for an agent to invoke the tool confidently.

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

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

Schema description coverage is only 33%: tag and item_type are bare strings with no descriptions or enums, and the description does not explain them at all. The description fails to compensate for the low coverage, and the meaning of 'overwrite' on a catalog-browsing tool is not clarified.

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

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

States a specific verb (Browse) and resource (Hyperframes catalog blocks/components), so the agent can tell this is a listing/discovery tool. However, it does not differentiate from siblings like hyperframes_compositions or hyperframes_info, leaving some ambiguity about which catalog-oriented tool to choose.

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

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

The description gives no when-to-use guidance, no alternatives, and no conditions. It does not say when to use this versus hyperframes_compositions or hyperframes_add_block, nor does it mention prerequisites such as whether tags or item types must exist beforehand.

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

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

No annotations are provided, so the description carries the full behavioral burden. "List" implies a read operation, but the description does not explicitly state read-only behavior, pagination, ordering, error conditions, or why an overwrite parameter exists on a list tool. The unexplained overwrite parameter is a notable gap given the lack of annotations.

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

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

The description is short, front-loaded with the purpose, and uses a compact Args block. It wastes little space, though the Args formatting is somewhat redundant with the schema.

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

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

An output schema exists, so the description need not explain return values. For a simple two-parameter listing tool, the project_path explanation is helpful, but the unexplained overwrite parameter and absence of annotations leave an agent without enough context about side effects or behavior.

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

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

Schema description coverage is 50%. The description adds useful meaning for project_path by specifying that it must be an absolute path to the Hyperframes project directory, which the schema lacks. However, the overwrite parameter, which has a non-obvious semantic for a listing tool, is only documented in the schema and not addressed in the description.

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

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

The description states a specific verb and resource: "List compositions in a Hyperframes project." This is clear and distinguishable from mutation-heavy siblings, but it does not explicitly differentiate itself from adjacent read-oriented tools like hyperframes_catalog, hyperframes_inspect, or hyperframes_info.

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

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

The description gives no guidance on when to use this tool versus the many sibling tools. There are no exclusions, prerequisites, or named alternatives, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden. It does not say whether diagnostics are read-only, whether they may mutate state, what permissions are required, or what kind of checks are performed; only an output schema exists to cover return values.

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

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

A single front-loaded sentence with zero waste. It is appropriately sized for a simple diagnostic command.

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

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

The output schema and fully documented parameter reduce the need for return-value explanation. However, the absence of usage guidance and behavioral disclosure leaves gaps for an agent deciding when and how to invoke it safely.

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

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

Schema description coverage is 100%, and the single optional overwrite parameter is fully documented in the schema. The description adds no parameter-level meaning 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?

States a specific verb (Run) and resource (Hyperframes environment diagnostics). It is clear what the tool does in general, but it does not distinguish itself from sibling tools like hyperframes_validate, hyperframes_inspect, or hyperframes_info.

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

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

Provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusion conditions. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about side effects. Critically, the tool exposes an 'overwrite' parameter, which sits oddly with a 'print info' framing and hints at possible media replacement — the description never acknowledges or explains this, leaving real ambiguity about whether the call is purely read-only.

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

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

One short sentence with zero padding and front-loaded intent, but the terseness crosses into under-specification rather than efficient communication.

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

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

An output schema exists, so return values need not be explained, but the description still leaves the surprising 'overwrite' capability on an info tool completely unaddressed, which is exactly the kind of thing an agent needs before invoking it.

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

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

Schema coverage is 50%: 'overwrite' is documented in the schema, but 'project_path' is bare, and the description adds no meaning to either parameter. With a mutation-implying flag on an info tool, the description should have explained what overwrite affects here, and it does not.

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?

It states a verb+resource ('Print Hyperframes project metadata'), so the general intent is legible, but 'metadata' is undefined and nothing distinguishes it from the many sibling probes such as hyperframes_inspect, hyperframes_catalog, or hyperframes_compositions.

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

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

There is no guidance on when to call this versus hyperframes_inspect or hyperframes_catalog, and no mention of prerequisites (does the project need to exist / be initialized?). The agent must infer selection purely from the name.

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

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

No annotations are provided, so the description carries the full burden. It does disclose useful behavior: three named templates, Tailwind support, resolution presets, and that media bootstrap triggers Whisper transcription (with skip/model/language controls). It never addresses the write-side risks, like what files are created, or what happens when output_dir already exists.

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

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

The leading sentence is front-loaded and the rest is a compact, scannable parameter list with no filler prose. A few lines restate the schema title rather than adding meaning ('name: Project name.'), but overall the length is proportionate to an 11-parameter tool.

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

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

An output schema exists, so return values need not be described, and parameter coverage is adequate. For a filesystem-mutating scaffold with zero annotations, though, the description omits directory-existence behavior, overwrite semantics outside the schema, and any required setup, leaving gaps an agent would care about.

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

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

Schema description coverage is only 9%, so the description has to compensate, and it does: all 11 parameters get a line, and the template argument exposes concrete values (blank, warm-grain, swiss-grid) that the schema lacks. Some entries are thin; 'model: Whisper model for transcription' and 'resolution: Hyperframes canvas resolution preset' give no valid values or examples.

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

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

The first sentence gives a specific verb and resource: 'Scaffold a new Hyperframes project.' An agent can see this is project bootstrap, not render or inspect. It never differentiates itself from similar siblings such as video_project_create, video_init_project, or revideo_materialize, so it stops short of a 5.

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

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

The description says nothing about when to use this tool, when not to, or how it relates to video_project_create / video_init_project. An agent has to infer that scaffolding must precede hyperframes_render. The per-parameter defaults help with invocation but are not usage guidance.

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

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

No annotations are provided, so the description must carry the full behavioral burden. 'Inspect' suggests a read-oriented operation, but the description does not disclose whether rendering occurs, whether files or reports are written, permission requirements, or side effects; it only adds the inspection target.

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

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

The description is a single front-loaded sentence with no wasted wording. It is concise, though its brevity is also the source of the missing guidance captured in other dimensions.

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

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

The presence of an output schema reduces the need to describe return values, but this is an eight-parameter tool with no annotations and very low parameter documentation. The description is far too thin to make the tool's invocation behavior and parameter usage sufficiently clear.

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

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

Schema description coverage is only 13%, with just the overwrite parameter documented in the schema. The description does not explain the meanings of at, strict, samples, tolerance, max_issues, timeout_ms, or project_path, so it fails to compensate for the low schema coverage across eight 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 states a specific verb and resource: inspect rendered composition layout, focused on overflow and visual issues. It is clear what the tool does, but it does not explicitly distinguish itself from nearby siblings such as hyperframes_validate, hyperframes_snapshot, or hyperframes_preview.

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

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

The phrase 'for overflow and visual issues' implies when the tool is useful, but there is no explicit guidance on when to use it instead of hyperframes_validate, hyperframes_snapshot, or other inspection/validation siblings. No prerequisites, exclusions, or alternatives are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions the default port but does not disclose server lifecycle, whether the preview process is long-running/blocking, permission requirements, or the implications of the overwrite parameter for replacing existing media.

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

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

The description is short and front-loaded with the main purpose, followed by compact argument notes. It avoids unnecessary filler, though the Args block is somewhat terse and could integrate parameter relevance more cleanly.

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 presence of an output schema reduces the need to describe return values, and the description covers the basic launch action. However, for a tool with no annotations and an overwrite option, it omits important operational context such as server lifecycle and replacement behavior.

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

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

Schema description coverage is only 33%, so the description should compensate. It usefully clarifies that project_path must be an absolute path and restates the port default, but it completely omits the overwrite parameter, which is the most behaviorally significant input.

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

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

States a specific verb and resource: launch the Hyperframes preview studio for live preview. It is clear what the tool does, though it does not explicitly distinguish it from sibling preview-related tools such as video_preview or hyperframes_snapshot.

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

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

The phrase "for live preview" gives implied usage context, but there is no explicit guidance on when to use this versus alternatives like hyperframes_snapshot or hyperframes_capture, nor any exclusions or prerequisites.

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

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

No annotations exist, so the description must carry the full burden. It usefully discloses that the default model won't fall through to people, that birefnet-general requires an extra pip extra, and that info=True lists models without downloading. It says nothing about GPU/device behavior, cost, mask_interval effects, or what equipment_overlay does, which for an 11-param tool is a real gap.

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

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

The core capability is front-loaded in one sentence, and the model-selection rule follows immediately. It is reasonably tight, though the heavy use of RST backticks and stray line breaks slightly hurts scanability.

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

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

An output schema exists, so return values needn't be covered, but for an 11-parameter tool with 9% schema coverage, several cryptic knobs are explained nowhere. The agent would have to guess at mask_interval, equipment_overlay, and fail_if_equipment_on_subject semantics before calling it.

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

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

Schema description coverage is only 9%, so the description should compensate, yet it only explains model and info. Eight other parameters (device, quality, mask_interval, equipment_overlay, background_output_path, fail_if_equipment_on_subject, input_path, output_path) get no meaning from either source; the schema's bare types/defaults don't tell an agent what mask_interval or equipment_overlay actually do.

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

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

The description gives a concrete verb and resource: 'Cut a person or a product out of a still or video', which makes the capability obvious. It doesn't contrast with close siblings such as video_chroma_key, video_luma_key, or video_apply_mask, so the agent must infer which matte tool to use.

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?

Within the tool it routes usage well: the default model is described as people-only and birefnet-general is prescribed for products, packaging, jewelry, etc. But it never says when to prefer this tool over the many sibling masking/keying/removal tools, so the selection guidance is only implied at the sibling level.

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

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

No annotations are provided, so the description carries the full disclosure burden. It does not mention that this is a long-running/heavy operation, whether it overwrites existing output, what happens on failure, or any resource/permission considerations beyond the terse parameter list.

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

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

Purpose is front-loaded in one line, followed by a compact per-parameter list where each line adds information not present in the schema. Slightly long, but with near-zero schema coverage the enumeration earns its space.

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

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

An output schema exists, so return values do not need explanation, and the core render parameters are covered. However, for a 26-parameter mutation tool with no annotations, the missing behavioral profile and the undocumented half of the parameters leave clear gaps.

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

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

Schema description coverage is only 4%, so the description does real work: it documents 13 of 26 parameters with allowed values and defaults (fps 24/30/60, quality draft/standard/high, format mp4/webm/mov/png-sequence, resolution presets, workers 'auto', crf direction). It leaves roughly half undocumented (gpu, hdr, sdr, docker, strict*, quiet, video_bitrate, max_concurrent_renders), so it is not fully complete but clearly compensates for the barren schema.

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

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

States a specific verb and resource: 'Render a Hyperframes composition to video.' The 'Hyperframes composition' scoping differentiates it from revideo_render, though the description never explicitly contrasts with hyperframes_preview or hyperframes_still.

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

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

There is no statement of when to use this tool versus sibling renderers/previewers like revideo_render, hyperframes_preview, or hyperframes_still, and no prerequisites mentioned. The agent must infer the context from the name alone.

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

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

No annotations, so the description carries the full disclosure burden, and it discloses almost nothing: it doesn't say whether files are written to disk, where, whether existing output is replaced, how long capture takes, or whether a render must precede it. The 'overwrite' parameter in the schema hints at destructive file behavior that the prose never surfaces.

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

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

A single front-loaded sentence with no filler — the action and output format come first. It is efficient, though its brevity borders on under-specification for a 7-parameter tool.

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

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

An output schema exists, so return values needn't be described, but with seven parameters, 14% schema coverage, no annotations, and no mention of prerequisites or file-writing behavior, the description leaves the agent without enough to call this correctly on a non-trivial project.

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

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

Schema description coverage is only 14% (just the 'overwrite' param), yet the description says nothing about what 'at' (timestamp list), 'frames' (default 5), 'variables'/'variables_file', or 'timeout_ms' mean or how they interact. 'Key frames' loosely gestures at at/frames but supplies no semantics to compensate for the coverage gap.

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

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

The description states a specific verb and resource — capturing key frames as PNG screenshots — plus a purpose (visual verification). It does not, however, distinguish this from near-siblings like hyperframes_still, hyperframes_capture, video_extract_frame, or video_export_frames, all of which plausibly do comparable frame extraction.

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

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

'For visual verification' implies a review/QA context but gives no explicit when-to-use rule, no prerequisites (does it need a rendered project first?), and no named alternative when the agent already has a frame-extraction tool. Usage must be inferred.

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

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

With no annotations, the description carries the full behavioral burden and doesn't meet it: it doesn't say an image file is written to disk, whether existing files are replaced, or that overwrite must be set explicitly (that fact lives only in the schema). It does add the useful note that output_path is auto-generated when omitted.

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

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

Front-loaded one-sentence purpose followed by an Args list where each line adds real semantics (path type, default, inline-vs-file). No redundant prose, though the Args block is a bare docstring dump rather than tailored guidance.

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

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

An output schema exists, so return values needn't be described. But for a file-writing render tool with zero annotations, the description omits the sibling disambiguation and the overwrite/protection behavior that an agent needs to call it safely.

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

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

Schema description coverage is only 17%, so the description must compensate and largely does: it explains project_path as an absolute project directory, output_path fallback behavior, frame numbering with default 0, and crucially the distinction between inline `variables` and `variables_file`. The one uncovered parameter, overwrite, is documented in the schema itself.

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

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

States a specific verb and resource: 'Render a single frame as image from a Hyperframes composition.' That is clear and concrete, but it never distinguishes the tool from close siblings like hyperframes_snapshot, hyperframes_capture, or hyperframes_preview, which an agent must otherwise infer.

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

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

No guidance on when to use this versus hyperframes_snapshot/capture/preview/render, nor any prerequisites (e.g., project must be initialized or validated). The reader is left to guess from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that output_path is auto-generated when omitted; it says nothing about runtime/long-running behavior, whether rendering is idempotent, what happens on partial failure of post-processing, or what permissions/auth the pipeline needs.

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 one-line summary is front-loaded and states the core value proposition, followed by a compact Args block. The docstring formatting is mildly wasteful but every line conveys usable information, and there is no filler.

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

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

An output schema exists so return values need not be explained, but for a two-stage render pipeline the description omits critical context: which composition in the project is rendered, the vocabulary of valid post-processing ops, and failure/overwrite semantics beyond the schema's own overwrite field. An agent cannot reliably construct a correct post_process list from this alone.

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

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

Schema description coverage is 25% (only 'overwrite' is documented), so the description must compensate — and it partly does: it gives an example post_process structure with 'op'/'params' keys and clarifies output_path auto-generation. However, it never enumerates valid 'op' values or their params, leaving the most complex parameter only half-specified.

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

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

Specific verb+resource: 'Render a Hyperframes composition and post-process with mcp-video in one step' clearly states it is a combined render+post-process pipeline. It is distinguishable from hyperframes_render (render only) by implication of the post-processing stage, though the sibling is never named.

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

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

Usage is only implied by the tool name and the phrase 'in one step' — an agent can infer this is the choice when post-processing is needed alongside rendering. There is no explicit when-not guidance, no mention of hyperframes_render as the simpler alternative, and no stated prerequisites for the Hyperframes project.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether transcription writes files, whether existing files are replaced, what permissions or model prerequisites are needed, or how import mode differs behaviorally from transcription. The overwrite safety detail lives only in the schema and is not surfaced in the description.

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

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

The description is a single front-loaded sentence with no wasted words. Its brevity is efficient, though it borders on under-specification rather than polished concision. It is structurally sound but thin.

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

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

With 5 parameters, low schema coverage, no annotations, and two apparent modes, the definition is not complete enough for reliable invocation. Although an output schema exists and need not be explained, critical gaps remain around parameter effects, file handling, and mode selection. The description does not do enough to make the tool safely callable.

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

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

Schema description coverage is only 20%, so the description should compensate for undocumented parameters like model, language, input_path, and project_path. Instead it adds no per-parameter meaning and does not explain how those parameters affect transcription, import, or project placement. It only hints at output granularity (word-level timestamps), leaving most parameter semantics unexplained.

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

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

The description states a specific verb and resource: transcribe audio/video into word-level timestamps, or import transcripts. That is clear enough to know what the tool does. However, it does not differentiate from close siblings such as video_ai_transcribe, video_generate_subtitles, or video_subtitles, so an agent cannot tell when this tool is the right one without inspecting schemas.

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

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

The phrase "or import transcripts" hints at two modes but never states when to choose transcription versus import. There is no guidance on when to use this instead of sibling tools like video_ai_transcribe or video_generate_subtitles. No exclusions, prerequisites, or context cues are provided.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about file writing, overwriting behavior, or permission/error conditions. A mutation tool with 7 optional parameters and no safety profile leaves the agent guessing about side effects.

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

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

A single compact sentence with the main action front-loaded, so nothing is wasted. But the brevity is under-specification rather than efficiency given the tool's 7 parameters and dual mode.

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?

Output schema exists so return values needn't be explained, but for a 7-parameter tool with zero required params and two distinct modes, the description leaves critical gaps—how text_or_file, output_path, and list_voices interact is undocumented. It is far too thin for this complexity.

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

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

Schema description coverage is only 14% (just the overwrite field), and the description adds no parameter meaning—nothing explains text_or_file, output_path, voice, language, or speed semantics. Only 'voices' loosely maps to the voice/list_voices 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?

Names a specific verb+resource ('Generate speech audio') plus a second mode ('list available Hyperframes local TTS voices'), so the agent can tell what it does. It stops short of differentiating from close siblings like audio_synthesize, sound_voice_batch, or hyperframes_transcribe.

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

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

There is no guidance on when to choose this over audio_synthesize or sound_voice_batch, which occupy nearly identical territory. The 'or list' phrasing implies list_voices mode exists but never states when to use it versus generating audio.

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

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

No annotations exist, so the description carries the full burden — and it omits the key behavioral question: does validation mutate the project? The presence of an 'overwrite' parameter ('Explicitly allow replacing existing media') implies possible write behavior that the description never acknowledges. It also says nothing about strictness, failure modes, or whether it blocks rendering.

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

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

One purpose sentence followed by an args block; front-loaded and free of filler. The Args block partially duplicates the schema, but the whole definition is short enough that this costs little.

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

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

An output schema exists, so return values needn't be described. But for a validation tool with no annotations, a puzzling write-related parameter, and many similar sibling checkers, the definition does not give an agent enough to call it confidently or in the right order.

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 description supplies the one piece the schema lacks for the required parameter ('Absolute path to the Hyperframes project directory'), which compensates for the 50% coverage. However, it adds nothing about 'overwrite' — the schema documents it but the description never explains why a validation tool accepts a media-replacement flag, leaving a genuine semantic gap.

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

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

States a specific verb and resource plus a scope ('Validate a Hyperframes project for rendering readiness'), which is clearly distinguishable from render/preview tools. It does not, however, distinguish itself from close siblings like hyperframes_doctor, hyperframes_inspect, or video_preflight, which plausibly do overlapping checks.

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

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

There is no explicit when-to-use, no prerequisites, and no named alternative. 'For rendering readiness' only weakly implies it runs before hyperframes_render; the agent is left to infer sequencing and whether doctor/preflight should run first.

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

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

With no annotations, the description carries the full load and does it well: it discloses that color extraction is local, that the legacy description adapter is disabled by default even with an API key present, that it requires KINOCUT_VISION_MODE plus a loopback base URL, and that it does not inherit host routing. It does not describe failure behavior for bad paths or how video frames are chosen, which keeps it below 5.

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

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

The purpose and the key routing advice are front-loaded in the first two sentences, and the numbered Args section is easy to scan. The consent block is dense and slightly overlong relative to the size of the operation, but every sentence carries operational meaning.

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

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

An output schema exists, so return values need not be explained, and the description covers the mutation/replace semantics only indirectly through the schema-documented overwrite flag. For a four-parameter tool with non-obvious provider gating, the description supplies what an agent needs to call it correctly.

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

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

Schema coverage is only 25%, so the description must compensate, and it does: image_path is documented as an absolute path that also accepts video files (with representative-frame extraction), use_ai carries its full environment gating, and n_colors states the default and meaning. The one undescribed parameter, overwrite, is already documented in the schema.

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

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

The first line gives a concrete verb+resource: analyze a product image or video frame, extracting colors and optionally an AI description. It is specific enough for an agent to know what it does, but it never distinguishes itself from close siblings such as image_extract_colors or image_generate_palette, leaving the agent to infer which of the three to pick.

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 routes the agent away from use_ai for provider-neutral descriptions ('inspect the image with your host's configured vision model'), and it states the operator-consent preconditions under which use_ai actually works. What's missing is any comparison to the color-extraction siblings, so the guidance covers context but not sibling 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?

No annotations are provided, so the description carries the full burden. It discloses important behavior: intent is audit metadata only, paid generation is unavailable, dry_run does not mutate pixels, and the v1 path is limited to mean-RGB matching.

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 contains useful details but is dense, jargon-heavy, and not front-loaded. It also repeats the audit-only role of intent across the opening paragraph and the Args section.

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

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

For an 8-parameter tool with no annotations and low schema coverage, the description covers the key operational limits, dry-run behavior, and most parameter semantics. Output schema exists, so return-value details are not required.

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

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

Schema description coverage is only 13%, but the description documents 7 of the 8 parameters, including the meaning of intent, the prefer values 'edit' and 'gen', dry_run, and allow_paid_gen. Overwrite is omitted from the description, though the schema itself describes 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 eventually says the tool performs an establish/reference mean-RGB still match and can return a plan, but the opening phrase 'Establish-locked still match with plan/receipt' is opaque and does not clearly differentiate it from siblings such as still_match or still_grade.

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 constraints (v1 is free mean-RGB only, paid generation fails, dry_run returns a plan) but does not say when to use this tool versus alternatives like still_match, still_grade, or image generation tools.

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

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

With no annotations, the description carries the full burden. It discloses the algorithm (K-means), the returned fields, and the video-frame behavior, which is solid. However, the presence of an `overwrite` parameter implies the tool may write or replace files, and the description never mentions any output artifact, side effect, or replacement semantics.

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

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

The description is front-loaded with purpose and return shape, followed by a clean Args block. The K-means sentence is mildly redundant with "dominant colors" but it adds real methodological detail and costs little.

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

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

An output schema exists, so the return-value listing is a bonus rather than a necessity, and the two extraction parameters are well covered. The gap is the write/overwrite behavior, which is not explained anywhere in prose and matters for a tool sitting alongside many file-producing siblings.

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

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

Schema coverage is only 33% (only `overwrite` is documented in the schema), so the description must compensate. It does well for `image_path` (absolute path, video handling) and `n_colors` (range 1-20, default 5), but `overwrite` — the one parameter the schema does cover — is never mentioned, leaving the write/destructive semantics of this tool unaddressed.

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

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

The description opens with a specific verb and resource: "Extract dominant colors from an image or video frame," and it names the algorithm and the return fields. It does not distinguish itself from the closest sibling, image_generate_palette, which an agent could easily confuse it with.

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

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

Usage is implied by the purpose statement; no explicit when-to-use, when-not-to-use, or alternative is given. The note that a video input triggers representative-frame extraction is useful context but is behavioral, not routing guidance.

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

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

With no annotations, the description carries the full burden, and it omits the most consequential behavior: the presence of an 'overwrite' parameter implies this tool writes media to disk, yet the description never says it produces an output file, where it lands, or what happens on collision. It does disclose the video-frame-extraction behavior, which is real added value, but the write path is left implicit.

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

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

One front-loaded summary sentence followed by a compact Args block; every line carries information. Slight structural redundancy between the first sentence and the Args entry for image_path, but no filler.

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

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

An output schema exists, so return values need not be spelled out, and the inputs are well covered. What is missing for a tool with four params and zero annotations is the side-effect model: whether files are written, where, and how overwrite interacts with that.

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

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

Schema description coverage is only 25% (only 'overwrite' is documented in the schema), so the description must compensate, and it largely does: it explains image_path accepts video too, enumerates the harmony values that the schema leaves as a bare string with no enum, and gives n_colors' meaning plus default. Only 'overwrite' is unreferenced, but that one is covered by the schema itself.

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

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

The description opens with a specific verb and resource ('Generate a color harmony palette from an image or video frame') and then names the underlying mechanism (dominant color extraction plus color-theory harmonies). That is enough to tell it apart from the many video/* siblings, but it never explicitly distinguishes itself from image_extract_colors, which sounds adjacent.

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

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

There is no statement of when to pick this over image_extract_colors or the still_* / video_* image tools, and no prerequisites or exclusions. The only contextual hint is the passing note that video inputs get a representative frame extracted, which is behavior rather than guidance.

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