pastorsimon1798/mcp-video

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

With no annotations, description provides basic behavior (mixing, volume, loop, output) but lacks error handling, file constraints, or mixing details like sample rate handling. Incomplete for full transparency.

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

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

Efficiently structured with a one-line summary followed by structured args and returns. No unnecessary words; every sentence adds value.

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

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

Covers all parameters and return value. Lacks details on looping behavior (what happens when loop=true?) and error cases. Good but could be more complete for a 3-param tool with no annotations.

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

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

Schema coverage is 0%, so description fully compensates by explaining each parameter: tracks as list of configs with file, volume, start, loop; duration as total seconds; output_path as absolute path. Adds crucial meaning.

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

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

Clearly states it layers multiple audio tracks with volume mixing, distinguishing it from siblings like audio_effects or audio_synthesize. The verb 'layer' and resource 'audio tracks' are specific.

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?

Implied usage for mixing multiple WAV files with volume control, but no explicit when-to-use or when-not-to-use guidance. No alternatives mentioned despite many sibling audio tools.

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

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

No annotations exist, so description carries full burden. It discloses processing a chain but omits behavioral traits like destructive nature (overwriting output), file size limits, sample rate requirements, or permission needs. Only basic processing is mentioned.

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?

Description is concise with a clear structure: one-line summary, brief explanation, Args/Returns section. No redundant sentences, but could be slightly more compact.

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

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

Given no annotations and moderate complexity, the description covers basic function but lacks details on effect parameter constraints, file format restrictions, and return format. Output schema exists but is not described; description mentions success dict.

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 0%, so description must compensate. It specifies input/output paths as absolute paths and describes effects as a list with type and additional params, giving examples. However, it does not detail the additional params per effect type.

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 it applies an audio effects chain to a WAV file, listing specific effects like reverb, filtering, and normalization. It distinguishes from sibling tools like audio_preset and audio_sequence by focusing on custom effect chains.

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 use for applying multiple effects but lacks explicit guidance on when to use vs alternatives like audio_preset or when not to use. No exclusions or context 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. It mentions that no external audio files are needed and lists parameters, but it does not disclose side effects like file overwriting, permission requirements, or error behaviors. The description is adequate but missing key behavioral details.

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

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

The description is well-structured: a brief purpose statement, a bullet list of presets, and an Args section. It is relatively concise while containing necessary information. Minor redundancy like repeating 'preset' could be trimmed.

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

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

Given the tool has 5 parameters, 1 required, and an output schema exists, the description covers the purpose, available presets, parameter details, and return value. It is fairly complete, though it could mention overwrite behavior on output_path and potential errors for invalid presets.

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

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

The input schema has 0% parameter description coverage, meaning the schema only provides names and types. The description compensates fully by providing an 'Args' section with detailed explanations for each parameter, including preset list, absolute path requirement, pitch options, duration in seconds, and intensity range. This adds significant meaning.

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

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

The description clearly states it generates preset sound design elements and lists available categories, making the tool's purpose clear. However, it does not explicitly differentiate from sibling tools like audio_synthesize, which could also generate audio.

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

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

The description implies usage for predefined presets but does not provide explicit guidance on when to use this tool versus alternatives such as audio_compose or audio_synthesize. No when-not or exclusion criteria are mentioned.

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

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

No annotations are provided, so the description carries full burden. It mentions creating a layered track and returning success/output_path, but does not disclose whether output_path overwrites existing files, or any side effects like file system permissions. Basic transparency, but missing details.

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 relatively concise, using bullet points in Args. However, it repeats the first sentence 'Compose multiple audio events...' and 'Creates a layered audio track...' which is slightly redundant. Still efficient overall.

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 input parameters and return value in a way that is sufficient for understanding the tool's usage. Given the complexity (array of objects without a predefined schema), it provides enough context. Missing elements like error handling or file overwrite behavior are minor 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 0%, but the description compensates by detailing the structure of sequence items (type, at, duration, freq/frequency, name, volume, waveform) and explaining output_path. This adds significant meaning beyond the raw schema, though the schema's additionalProperties:true leaves some ambiguity.

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

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

The description clearly states the tool composes multiple audio events into a timed sequence, using specific verbs like 'Compose' and 'Creates a layered audio track'. It distinguishes from siblings like 'audio_synthesize' (single sound generation) and 'audio_preset' (preset sounds) by emphasizing the combination of multiple events.

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

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

The description implies the tool is for creating timed sequences from multiple events, but does not explicitly state when to use it over alternatives or provide exclusions. No guidance on prerequisites or comparison with sibling tools is given.

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

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

No annotations are provided, so the description carries full burden. It describes the process and supported effects but does not mention file overwrite behavior, performance considerations, or permissions. It is transparent about what it does but lacks potential behavioral details.

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

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

The description is well-structured with a brief summary followed by a parameter list. Every sentence adds value, no unnecessary words. Efficient and clear.

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

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

The description covers all parameters, effects, and return value. Minor omission: no mention of file overwrite behavior or limitations (e.g., max duration). However, given complexity, it is largely complete.

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

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

Schema coverage is 0%, so description must add meaning. It provides defaults and detailed explanation of the effects parameter with sub-keys (envelope, fade_in, fade_out, reverb, lowpass). This significantly enhances understanding beyond the bare 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 'Generate audio procedurally using synthesis' and 'Creates WAV files from scratch using mathematical waveforms'. It distinguishes from siblings like audio_compose (which likely composes existing audio) by emphasizing no external audio files needed.

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

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

The description implies usage for generating audio from scratch using synthesis, but does not explicitly state when to use this tool vs alternatives like audio_compose or audio_effects. No 'when not to use' or direct comparisons.

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

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

No annotations provided, so description carries full burden. It explains the effect (RGB split) and parameters, but does not disclose side effects, prerequisites, or file requirements. Adequate but could be more detailed.

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?

Concise with a clear intro, Args section, and Returns. Every sentence adds value. No wasted words.

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

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

Covers purpose, parameters, and return value. For a simple video effect, this is near complete. Could mention input video existence or that it's an effect applied to video, but not critical.

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

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

Adds meaningful descriptions for all 4 parameters beyond the schema, which only has names and defaults. Describes intensity as 'Pixel offset amount', angle as 'Separation direction'. Also explains return value.

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

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

Clearly states 'Apply chromatic aberration - RGB channel separation' with a specific verb and resource. Mentions it's a trendy RGB split effect for glitch aesthetics, but does not explicitly distinguish from similar sibling tools like glitch_rgb_shift.

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

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

Implies usage in tech/glitch contexts but provides no explicit guidance on when to use this tool over alternatives. No when-not or alternative tool names are given.

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

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

No annotations are provided, so the description carries full burden. It describes the glow effect but does not disclose behavioral traits such as whether the operation is destructive, if it modifies the input file, performance implications, or side effects. The existence of input/output paths suggests non-destructive creation, but this is not explicitly stated.

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

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

The description is concise and well-structured: a one-line summary, a one-sentence elaboration, a clear args list with explanations, and a returns note. It is front-loaded with purpose and contains no extraneous information.

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

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

The description covers all parameters effectively and returns a dict with status and output_path. While it does not address edge cases or required permissions, the output schema exists to clarify returns. For a single-effect tool with moderate complexity, it is largely 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?

With 0% schema description coverage, the description adds significant value by explaining each parameter: intensity as 'Glow strength 0-1', radius as 'Blur radius in pixels', threshold as 'Brightness threshold 0-1', all with defaults. This goes beyond the schema which only provides types and defaults.

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

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

The description explicitly states 'Apply bloom/glow effect for highlights' and 'Creates a soft glow around bright areas of the video,' clearly defining the tool's specific purpose. This differentiates it from sibling effect tools like effect_chromatic_aberration, effect_noise, etc.

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 through the purpose statement (e.g., for highlights), but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention when not to use it. Context is implied but not elaborated.

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 bears full responsibility for disclosing behavioral traits. While it mentions it writes to an output path, it does not disclose whether the operation is destructive, whether it modifies the original, or any permission requirements. This is insufficient for a mutation tool.

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

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

The description is extremely concise: two brief introductory sentences followed by a structured parameter list. Every sentence adds value without redundancy or 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?

The tool is simple with 5 parameters. The description covers all parameters with defaults, explanations, and even a return value summary. Given that an output schema exists (not shown but indicated), the description is fully sufficient for an agent to use the tool correctly.

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

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

Schema description coverage is 0%, but the description includes a detailed parameter list with meanings, defaults, and ranges (e.g., intensity 0-1, mode options). This adds significant value beyond the plain 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?

Description clearly states 'Apply film grain or digital noise' and specifies it 'Adds texture noise to video for vintage or lo-fi aesthetics.' This is a specific verb-resource combination that distinguishes it from sibling tools like effect_glow or effect_scanlines.

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

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

The description implies usage for vintage/lo-fi aesthetics but provides no explicit guidance on when to use this tool versus alternatives like effect_scanlines or glitch effects. No when-not-to-use or exclusion criteria are given.

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

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

No annotations provided, so description must cover all behavioral traits. It mentions optional flicker but does not disclose whether the operation is destructive, permission requirements, or output format details beyond a dict.

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 paragraphs: first line defines purpose, then concise Args list. Front-loaded, no fluff.

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

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

Given the context of many sibling effects, the description adequately defines the effect and return value. Could mention limitations (e.g., codec support) but overall sufficient for a simple filter.

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?

Input schema has 0% description coverage, so description compensates by explaining each parameter with defaults and ranges (e.g., 'Pixels per scanline', 'Line opacity 0-1'). Adds meaning beyond schema types.

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 'Apply CRT-style scanlines overlay' with a specific verb and resource. It distinguishes from sibling effects like chromatic_aberration or glow by focusing on the CRT monitor scanline effect.

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

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

No explicit guidance on when to use scanlines over other effects. The description implies use for CRT-like aesthetics, but does not contrast with siblings or mention prerequisites.

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

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

No annotations are provided, so the description carries full burden. It discloses the effect (darkened edges), parameters, and return value. It does not mention any destructive actions or permissions, but the behavior is clear and non-contradictory.

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

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

The description is concise with a front-loaded purpose, followed by clear parameter documentation. Every sentence adds value, and there is no redundant or unnecessary information.

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

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

Given the simplicity of the tool and presence of an output schema, the description is complete. It covers all inputs and the return value (Dict with success status and output_path), leaving no gaps for an agent to invoke 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?

The input schema has 0% description coverage, but the Args section in the description explains each parameter's meaning, range, and default values (e.g., intensity 0-1, radius 0-1, smoothness 0-1). This fully compensates for the schema 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 clearly states 'Apply vignette effect - darkened edges' and explains it creates a darkened border that draws attention to the center. This distinguishes it from sibling effects like chromatic aberration or glow.

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 does not provide any guidance on when to use this tool versus other effect tools or alternatives. It only describes what the tool does without context for 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 provided, so the description must carry the burden. It mentions shifting channels and simulating offset print errors but does not disclose side effects, destructive potential, authentication needs, or rate limits. The behavioral impact is under-specified.

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 relatively concise with a clear structure: brief intro, then Args/Returns. Front-loaded with purpose. Could be slightly tighter, but no wasted sentences.

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

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

Given the tool has 5 parameters, no annotations, and many sibling glitch tools, the description is incomplete. It barely explains the effect, doesn't cover performance or combination guidelines, and the Returns section is minimal. More detail would help differentiation.

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 0%, so the description must compensate. It explains parameters (input_path, output_path, amount, angle, noise) in the Args section with defaults, but lacks detailed semantics (e.g., how angle interacts with amount). Provides baseline value but not comprehensive.

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 'Apply CMYK split glitch effect' and explains it shifts RGB channels at 90-degree intervals to simulate registration errors, distinguishing it from sibling glitch tools like glitch_rgb_shift.

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 explicit guidance on when to use this tool versus alternatives. Does not mention prerequisites, typical use cases, or contexts where it should be avoided. Lacks differentiation from similar glitch 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?

The description explains the underlying mechanism (P-frame corruption, drift, reset), which conveys the behavioral effect. However, without annotations, it does not disclose whether the tool is destructive, modifies inputs, or has side effects like temporary file creation.

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

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

The description is short and front-loaded with the effect name and mechanism. It uses a numbered list for parameters and clearly indicates return type. Every sentence adds value.

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

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

Given the presence of an output schema, the description sufficiently covers input parameters, mechanism, and return value. However, it misses potential failure modes, required input formats, and performance considerations.

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 0%, so the description carries the full burden. It explains the purpose of each parameter (input_path, output_path, drift, iframe_interval) and provides defaults, which adds meaning beyond the schema. The optional/null nature of output_path 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?

The description clearly states 'Apply datamoshing glitch effect' and explains the simulation mechanism. It distinguishes the tool from general video tools but does not explicitly differentiate from the many glitch sibling tools (e.g., glitch_rgb_shift).

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

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

No guidance is provided on when to use this tool vs alternatives like other glitch effects or video filters. The description does not mention prerequisites, limitations, or scenarios where the tool is inappropriate.

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

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

No annotations provided, so description carries full burden. Explains that it extracts pseudo-depth from luminance and renders points, and returns a dict with success status and output_path, implying non-destructive output. Lacks explicit statement about side effects or file modification.

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?

Concise and well-structured: overview sentence, elaboration, then clear Args list with defaults, and Returns. No wasted words.

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

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

Covers all parameters, return format, prerequisite, and overall behavior. Despite having an output schema, the description provides enough context for an agent to understand input, output, and constraints for a complex effect 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 has 0% coverage, but description adds meaningful explanations for all 6 parameters including defaults and a range for threshold, significantly enhancing understanding beyond the schema's bare types.

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?

Clearly states it applies a depth-based point splatting effect, specifies the resource (video), and distinguishes from many sibling glitch tools by mentioning pseudo-depth and 3D particle-like appearance.

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?

Mentions a prerequisite (Node.js + GPU) but does not explicitly state when to use this tool versus the many other glitch effects available in the sibling list. Usage context is implied but not guided.

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

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

No annotations provided, so description carries full burden. Explains the iterative feedback algorithm, parameter defaults, and return value. Mentions required dependencies (Node.js + GPU). Does not discuss error handling or file overwrite behavior, but covers essential behaviors.

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 one-sentence summary, followed by a concise explanation of the effect, then a well-structured Args list. No unnecessary words or repetition.

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

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

Covers purpose, algorithm, parameters, return value, and dependencies. With 6 parameters and complex behavior, this is sufficient. Could include example usage or limitations, but remains comprehensive for the tool's complexity.

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

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

Schema description coverage is 0%, so description must compensate. Provides clear descriptions for all 6 parameters including types, purposes, and default values. Adds meaning beyond the schema's titles.

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?

Clearly states the tool applies a digital feedback glitch effect, explaining the iterative frame feedback process with scale/rotation transform. Distinguishes from sibling glitch tools like glitch_rgb_shift by describing the specific ghostly trails and recursive visual patterns.

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?

States prerequisites (Node.js + GPU) but does not provide explicit guidance on when to use this tool versus alternatives. No comparison to sibling glitch tools or exclusions for certain use cases.

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

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

No annotations provided, so description carries full burden. It explains the effect and parameters but does not disclose whether it modifies files in-place, performance costs, or destructive nature. Adequate but not thorough.

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?

Well-structured with title, effect explanation, and parameter list. Slightly verbose due to docstring style and redundant return info given output schema, but still efficient.

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

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

For a specialized effect tool with 5 parameters and output schema, the description covers essential information. Lacks prerequisites or performance hints, but overall complete.

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

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

Schema coverage is 0%, yet the description explains all 5 parameters with defaults and ranges (e.g., intensity 0-1). Adds meaning beyond schema, though output_path null behavior 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?

The description clearly states 'Apply macroblocking glitch effect' and explains it simulates codec artifacting via downscaling/upscaling. This distinguishes it from other glitch tools in the sibling list.

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 explicit guidance on when to use this tool vs other glitch effects (e.g., datamoshing, rgb shift). The description just explains what it does without comparisons or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses the effect's mechanics (sampling points, 3D rotation, depth displacement) and prerequisites, but does not reveal side effects, mutability, or required permissions. The return format is mentioned.

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 succinct and well-organized: a one-line effect summary, a detailed technical explanation, a bulleted argument list, and a return note. Every sentence adds value without redundancy.

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

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

For a tool with six parameters and no annotations, the description covers the core functionality, all parameters, and the return value. It mentions the GPU requirement and specifies input/output as video paths. Minor gaps exist (e.g., performance implications), but overall it is adequate.

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

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

All six parameters are individually described with clear meaning, ranges (e.g., density 0-1), and defaults. This fully compensates for the 0% schema coverage, providing essential context beyond the schema's type-only definitions.

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

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

The description clearly states the tool applies a 'point cloud rendering effect' with a specific verb and resource. It distinguishes from siblings by describing a unique 3D-rotated grid with depth-based displacement, setting it apart from other 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 lacks explicit when-to-use or alternative guidance, but it implies usage for creating volumetric point cloud looks. It mentions a prerequisite (Node.js + GPU) but does not differentiate from similar effects like glitch_depth_splatting.

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

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

No annotations provided, so description carries full burden. It discloses the effect (channel shift, noise) and return type, but does not mention side effects, destructive nature, file format limitations, or required permissions. Adequate but missing some safety/cost context.

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

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

Description is front-loaded with purpose, followed by a structured args list and return info. No unnecessary filler. The args section could be more integrated but is clear and efficient.

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

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

With output schema mentioned and parameters well-described, the description covers core functionality. However, it lacks details on error handling, supported formats, or performance implications. Adequate for a tool with no annotations.

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

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

Schema coverage is 0%, so description adds meaning by explaining each parameter's purpose and units (e.g., amount in pixels, angle in degrees, noise amplitude 0-1). Provides defaults. Could be more precise about edge cases but adds significant value.

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

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

The description clearly states the tool applies an RGB channel shift glitch effect, specifying it shifts red and blue channels in opposite directions and optionally adds per-frame noise. This distinguishes it from sibling glitch tools like glitch_cmyk_split or glitch_datamoshing.

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 does not explicitly mention when to use this tool over alternatives like other glitch effects. It implies usage for chromatic aberration effects but lacks guidance on 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?

The description explains the effect and all parameters, but lacks details on side effects, performance, or that it creates a new file without modifying the input. Annotations are absent, so description carries full burden.

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

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

The description is concise with two sentences plus a structured args list. It front-loads purpose and contains no unnecessary words.

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

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

The description sufficiently covers parameters and return value for a moderate complexity tool, but could include typical use cases or edge cases for additional completeness.

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

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

With 0% schema coverage, the description provides explanations for all 6 parameters, adding meaning beyond the schema. However, could include constraints like frequency range 0-1.

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

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

The description clearly states the tool applies a scanline jitter glitch effect, displacing random horizontal rows for a CRT look. It uses a specific verb 'apply' and distinguishes from sibling glitch and effect tools.

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

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

The description implies the tool is for a CRT malfunction look but does not explicitly state when to use it versus alternatives like other 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?

Since no annotations are provided, the description fully discloses the tool's behavior: it creates horizontal tear bands with configurable parameters affecting count, offset, and speed. It also states the return format (dict with success status and output_path). This is adequate for a non-destructive effect 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 concise with a clear Docstring-style format (Args, Returns). It front-loads the purpose and then details parameters. However, the Returns section is minimal (just 'Dict with success status and output_path') which could be more explicit.

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

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

Given the presence of an output schema and 5 parameters, the description covers all inputs and the return. However, it does not differentiate from the large set of sibling glitch tools, leaving the agent unsure which glitch effect to choose for a given task.

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

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

The input schema has 0% description coverage, but the description's Args section explains each parameter's purpose, default values, and type. This compensates well for the missing schema documentation, though the descriptions are terse.

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

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

The description clearly states the tool applies a screen tearing glitch effect and describes the visual outcome (horizontal tear bands shifting left/right). It is distinct from sibling glitch tools like glitch_rgb_shift or glitch_datamoshing.

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

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

No guidance is provided on when to use this tool versus alternatives like glitch_cmyk_split or glitch_vhs_tracking. The description does not mention any prerequisites, exclusions, or context-aware usage 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 provided, the description fully carries the burden of transparency. It describes the temporal sampling mechanism and notes GPU dependency, but does not disclose side effects (e.g., whether the input file is modified), performance implications, or error conditions. A richer disclosure would improve trustworthiness.

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 adequately sized with a clear first sentence for purpose, followed by an explanation and then structured args. The algorithm detail is concise, though the description could be slightly more streamlined by removing the illustrative sentence, which is helpful but not strictly necessary.

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

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

Given the tool's complexity (4 parameters, no annotations, and an output schema), the description covers input paths, parameter ranges, and return value. It lacks edge-case handling (e.g., invalid depth) and does not explain the output schema beyond a dict, but for the parameter count it is reasonably complete.

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

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

Schema description coverage is 0%, so the description must explain each parameter. It does so for all four: input_path (absolute path), output_path (optional), depth (range 1-120, default 30), direction (0-3 mapping). It adds meaning beyond the schema by specifying allowed values and defaults, though it could more explicitly connect depth to the effect's trade-offs.

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

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

The description clearly states the tool applies a slit-scan temporal displacement effect, explaining that each row/column is sampled from past frames. This specific verb-resource pair distinguishes it from sibling glitch effects like glitch_cmyk_split or glitch_datamoshing, which focus on color channel or data corruption rather than temporal smearing.

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 mentions that Node.js and GPU are required, setting a prerequisite but not explicitly guiding when to use this tool versus alternatives. It does not advise against use in certain scenarios or compare to similar effects, leaving the agent to infer applicability 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?

No annotations are provided, so the description carries the full burden. It describes the algorithm (layered sin/cos for fBm) and parameter effects, but omits details like whether the operation is destructive to the input (it writes to output_path) or computational cost.

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

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

The description is well-structured with a summary, technical explanation, argument list, and return type. It is front-loaded and every sentence adds value, though slightly verbose.

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

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

Given 6 parameters and an output schema (implied by return description), the description covers the effect, parameters, and return value. Lacks error conditions and usage context, but is sufficient for basic selection.

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 0%, but the description provides a complete Args block detailing each parameter with defaults and descriptions, significantly adding meaning beyond the schema.

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

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

The description begins with 'Apply turbulent displacement glitch effect,' which clearly states the verb and resource. It further explains the use of fractal Brownian motion noise for organic-looking displacement, distinguishing it from other glitch effects like cmyk_split or datamoshing.

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 explicit guidance on when to use this tool versus alternatives. The description implies the effect is for organic displacement but does not compare to other glitch tools or state prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It specifies that the tool simulates analog noise, color bleed, and rolling bands, and outputs a dictionary with success status and output path. It does not mention potential errors or side effects, but for a simple effect tool, this is minimally adequate.

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

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

The description is concise with a short opening line explaining the effect, followed by a clear list of parameters. It is well-structured and front-loaded, though the parameter list could be slightly more compact.

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

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

Given the tool's medium complexity (6 parameters, no nested objects, output schema exists), the description covers the purpose, parameters, and return value adequately. It does not delve into edge cases or error handling, but is sufficient for correct invocation.

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

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

The input schema has 0% description coverage, so the description compensates fully. Each parameter is explained with context (e.g., 'Tracking error intensity (0-1)', 'Red channel shift in pixels'), adding meaning beyond the schema's types and defaults. The return value is also described.

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

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

The description clearly states the tool applies a VHS tracking error glitch effect, with a specific verb ('apply') and resource ('VHS tracking error glitch effect'). It distinguishes from sibling glitch tools by specifying the VHS analog noise style.

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

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

The description implies the tool is for VHS-style glitch effects but does not explicitly state when to use it versus other glitch tools or provide exclusions. The agent must infer from the effect description 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?

The description fails to disclose key behavioral details. It implies a write operation ('Install') but does not explain side effects (e.g., whether blocks can be overwritten, if internet access is needed, or how 'no_clipboard' affects behavior). With no annotations, the description carries full burden but only covers basic purpose.

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

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

The description is extremely concise, with a single sentence stating purpose followed by a structured, bullet-like argument list. Every word serves a purpose, and the information is front-loaded. No unnecessary elaboration.

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 is incomplete given the tool's complexity. It does not explain the return value (despite an output schema existing), side effects, or the behavior of the omitted 'no_clipboard' parameter. An agent would need additional context to use the tool correctly.

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

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

The description adds meaning for the two required parameters beyond the schema's bare type: 'project_path' is specified as an absolute path, and 'block_name' includes an example. However, the optional 'no_clipboard' parameter is completely omitted from the description, reducing completeness given the low schema coverage (0%).

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

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

The description clearly states the tool's purpose with a specific verb ('Install') and resource ('a block from the Hyperframes catalog'). It distinguishes this tool from sibling tools like hyperframes_catalog (likely for browsing) and hyperframes_init (project setup), as it specifically focuses on adding a block to an existing project.

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

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

The description provides no usage guidance. It does not indicate when this tool should be used over alternatives (e.g., after browsing with hyperframes_catalog, or before using hyperframes_render). No prerequisites or subsequent steps are mentioned, leaving the agent without context on proper workflow.

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

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

No annotations provided, and description fails to disclose behavioral traits such as whether it modifies files, requires permissions, or has side effects. 'Benchmark' implies some execution but not enough detail.

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

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

The description is extremely short (5 words) but at the expense of necessary detail. It is under-specified rather than efficiently concise.

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

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

Although an output schema exists, the description is too minimal to provide adequate context for a benchmark tool with 4 parameters. Missing parameter explanations and usage context.

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

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

Schema description coverage is 0%, and the description does not explain any of the four parameters (project_path, output_path, runs, json_output). The meaning of these parameters is entirely absent.

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

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

The description clearly states the tool benchmarks Hyperframes render speed and file size. It distinguishes from sibling tools like hyperframes_render by focusing on benchmarking, but does not elaborate on scope or methodology.

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 vs. alternative tools such as hyperframes_render or hyperframes_preview. The description lacks context for appropriate usage.

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

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

No annotations are provided, and the description does not disclose behavioral traits such as side effects, required permissions, or what happens during capture. The description is too brief to compensate for missing 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 a single sentence, which is concise but lacks structure. It does not front-load critical information or organize details for clarity.

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

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

Given the tool's complexity (5 parameters, no annotations, an output schema not described), the description is insufficient. It leaves the agent without key context about behavior, return values, or parameter interactions.

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 0%, and the description does not explain any of the five parameters (url, output, skip_assets, max_screenshots, timeout_ms). The tool definition fails to add meaning beyond the bare 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 the verb 'capture', the resource 'a website', and the result 'editable Hyperframes components'. It effectively distinguishes from sibling tools like hyperframes_add_block or hyperframes_init.

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

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

The description provides no guidance on when to use this tool versus its siblings. There is no mention of prerequisites, limitations, or scenarios where it is most appropriate.

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

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

No annotations are provided, and the description is minimal. It does not disclose behaviors like pagination, filtering defaults, or read-only status. The tool is likely read-only but not stated.

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

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

The description is very concise (one sentence), but at the expense of necessary detail. It is front-loaded with the core action but lacks completeness.

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

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

An output schema exists, but the description does not cover how to use the parameters or what the output represents. For a catalog browser, more context on filtering and results is needed.

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 0%, and the description does not explain the parameters 'item_type' and 'tag'. The agent has no guidance on their meaning or usage.

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

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

The description uses a specific verb 'Browse' and resource 'Hyperframes catalog blocks/components', clearly distinguishing from sibling tools like hyperframes_add_block or hyperframes_render. However, it lacks detail on what 'browse' entails (e.g., list, search, filter).

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

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

No guidance is provided on when to use this tool versus alternatives. Given many sibling tools, explicit when-to-use and when-not-to-use context is missing.

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

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

No annotations are present, so the description must convey behavioral traits. The verb 'List' implies a read-only operation, which is sufficient for a simple listing tool. However, no further details are given about side effects, performance, or return characteristics.

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

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

The description is extremely concise with two sentences: one for purpose and one for the parameter. Every word adds value, and it is front-loaded with the core action.

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

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

Given the tool has one parameter and an output schema (which the description doesn't need to detail), the description is adequate but minimal. Missing usage context and behavioral details limit completeness.

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

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

The schema only defines the type as string with no description, so the description adds meaning by stating 'Absolute path to the Hyperframes project directory'. This clarifies the param's purpose, though it could include format 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 description clearly states the action 'List' and the resource 'compositions in a Hyperframes project', which directly matches the tool name. It is specific and distinguishes from sibling hyperframes tools that perform other actions like capture or render.

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 usage guidelines are provided. The description does not indicate when to use this tool over alternatives, nor does it mention prerequisites or situations where it should not be used.

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

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

No annotations provided. Description does not disclose any behavioral traits beyond 'run diagnostics,' such as what is checked, potential side effects, or if it is safe.

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?

Description is one short sentence, front-loaded with the key action. No wasted words.

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

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

Despite having an output schema, the description lacks detail on what diagnostics are performed or what the output indicates. For a diagnostic tool, more context is needed.

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?

No parameters. Schema coverage is 100%. Description does not add additional meaning but baseline for zero params is 4.

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

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

The description clearly states it runs diagnostics for the Hyperframes environment. This distinguishes it from siblings which are specific effects or video operations.

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 tool vs alternatives, such as whether to run before other operations or when troubleshooting. No mention of prerequisites or context.

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

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

No annotations provided, so the description must fully disclose behavior. It implies a read-only operation ('Print') but does not explicitly state it is non-destructive, require no authentication, or explain possible errors. Minimal behavioral insight.

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, front-loaded with the action. No waste, but the brevity sacrifices helpful details. Could be expanded slightly without losing conciseness.

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

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

Tool has an output schema but no description of return values. Given no annotations and vague parameter, the description leaves significant gaps for an agent unfamiliar with Hyperframes.

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 has zero description coverage for the sole parameter 'project_path'. The description does not explain what a valid project_path is (e.g., file path, URL, ID). No additional meaning beyond the type 'string'.

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

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

Description uses specific verb 'Print' and resource 'Hyperframes project metadata', clearly distinguishing it from sibling tools like hyperframes_init or hyperframes_capture. However, 'metadata' is somewhat vague, not specifying what aspects are included.

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 tool versus alternatives like hyperframes_inspect or hyperframes_info_detailed (if exists). The description does not mention prerequisites or exclusions, leaving the agent without context for 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 must carry the full burden. It does not disclose any behavioral traits such as whether it overwrites existing files, requires specific permissions, or what the output schema looks like. It only lists parameter descriptions.

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

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

The description is front-loaded with the purpose, and the parameter list is structured and concise. However, it could be more compact but is acceptable for the number of 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?

Given 10 parameters and no output schema description, the explanation is incomplete. It does not describe what the tool produces (e.g., file structure, project type) or any side effects.

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

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

The description includes a parameter block that adds meaning beyond the input schema, which has no descriptions. Each parameter is briefly explained, including defaults for some, which helps the agent understand usage.

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

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

The description clearly states 'Scaffold a new Hyperframes project', providing a specific verb and resource. This distinguishes it from other sibling tools like 'hyperframes_add_block' or 'hyperframes_capture'.

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 lacks guidance on when to use this tool versus alternatives, and does not provide any prerequisites or exclusions. The agent is left to infer that it's for project initialization.

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

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

No annotations provided, so description carries full burden. Only states purpose but does not disclose behavioral traits like whether it modifies data, requires a rendered composition, or has 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?

Description is a single concise sentence, but it lacks detail. It is not verbose, but the conciseness comes at the cost of informativeness.

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

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

Given the tool has 7 parameters and an output schema, the description does not cover return values, parameter roles, or any additional context. It is insufficient for complete understanding.

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 0%. Description provides no explanation of any of the 7 parameters, such as 'samples', 'tolerance', 'strict', etc. Fails to add meaning beyond the schema.

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

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

Description clearly states the tool inspects rendered composition layout for overflow and visual issues. It uses a specific verb and resource, distinguishing it from sibling tools like hyperframes_add_block or hyperframes_validate.

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 tool versus alternatives. No indications of prerequisites, context, 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?

No annotations exist, so the description must fully convey behavior. It mentions launching a server but does not disclose if it is blocking, how to stop it, or any side effects. Too minimal for a tool that starts a server.

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?

Extremely concise and front-loaded with the main purpose. Every sentence provides essential information without superfluous 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?

Given that an output schema exists (reducing need for return value explanation), the description is adequate for a simple launch tool. However, it lacks lifecycle context on server startup/teardown.

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 adds value by specifying that 'project_path' is an absolute path and giving the default for 'port'. This goes beyond the schema which only has titles and defaults.

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

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

The description clearly states the action ('Launch') and the specific resource ('Hyperframes preview studio for live preview'). It distinguishes from siblings like hyperframes_render and hyperframes_info by focusing on live 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?

No guidance on when to use this tool versus alternatives. The description does not mention prerequisites, lifecycle, or when to choose preview over other hyperframes tools.

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

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

No annotations are provided, so the description carries full burden. It fails to disclose any behavioral traits such as processing requirements, file limits, or what happens to the original files. The brief statement adds little beyond the function name.

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

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

The single sentence is front-loaded and concise, but it is too terse for a tool with 6 parameters. While it earns its place by stating the purpose, it lacks essential structure and completeness.

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

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

Given the tool has 6 parameters, no schema descriptions, no annotations, and no behavioral context, the description is severely incomplete. It does not explain output, usage prerequisites, or parameter constraints, making it inadequate for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not explain any of the 6 parameters (input_path, output_path, background_output_path, device, quality, info). It offers no semantics beyond the tool's general purpose.

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

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

The description clearly states the verb 'remove' and the resource 'video/image background' using 'Hyperframes local AI'. It distinguishes itself from sibling tools like video_chroma_key by specifying AI-based removal, and no other sibling has 'background' in its purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., chroma key). It simply states the function without any context of appropriate scenarios 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 provided, so description must fully disclose behavior. It only states the action and lists parameters, without revealing important traits like resource intensity, side effects, or whether output path overwrites. This is insufficient for a render 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?

Description is front-loaded with a clear single-sentence purpose. The parameter list is structured and readable, though lengthy. It effectively organizes 25 parameters without extra fluff.

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

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

While parameters are individually described, the description lacks an overall context (e.g., typical render workflow, expected output, or interaction with other params). Output schema exists but is not leveraged to explain return values.

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 0%, but the description compensates by giving inline explanations for each parameter (e.g., 'Absolute path to the Hyperframes project directory'). This adds substantial meaning beyond the schema's type-only definitions.

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

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

Description clearly states 'Render a Hyperframes composition to video', providing a specific verb and resource. This distinguishes it from siblings like hyperframes_preview or hyperframes_validate.

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 explicit when-to-use or alternatives guidance. The purpose is implied by the name and description, but the description does not clarify when to choose this over other hyperframes tools (e.g., still, preview).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states output is PNG and purpose is verification, but omits information about side effects, file destinations, permissions, or whether the operation is destructive.

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

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

The description is a single sentence with no fluff, but it is under-specified for a tool with 6 parameters. Essential details are missing, making it concise but insufficient.

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

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

Given the tool has 6 parameters, no annotations, and an output schema, the description is severely lacking. It provides no context on parameter usage, output format beyond 'PNG screenshots', or how to integrate with other 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?

The input schema has 6 parameters with 0% description coverage, yet the tool description adds no information about any parameter. It does not explain what 'key frames' means in context of the 'frames' or 'at' 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?

Description clearly states the action (capture), resource (key frames), output format (PNG screenshots), and purpose (visual verification). However, it does not distinguish from the sibling tool 'hyperframes_capture', which likely has a similar purpose.

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 tool versus alternatives like 'hyperframes_capture' or 'hyperframes_still'. The phrase 'for visual verification' implies a use case but does not provide explicit decision criteria.

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

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

No annotations are provided, so the description carries the full burden. It only states the basic operation (rendering a frame) but does not disclose whether the operation is read-only, destructive, or any side effects. For a tool that likely does not modify the project, this information would be helpful but is missing.

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

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

The description is concise: a single-sentence summary followed by a clear bullet list of parameters. No redundant or extraneous information. The structure is front-loaded with the key action.

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

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

The description covers the tool's core purpose and parameters. Given the presence of an output schema, it need not detail return values. However, it could briefly mention that the output is an image file, which is already implied by 'as image'. It is otherwise sufficiently complete for a single-frame rendering 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?

With 0% schema description coverage, the description compensates by explaining each parameter's purpose and expected values (e.g., 'Absolute path to the Hyperframes project directory'). This adds significant meaning beyond the schema's bare type definitions.

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 'Render a single frame as image from a Hyperframes composition', specifying the action (render), resource (Hyperframes composition), and output (single frame image). This distinguishes it from sibling tools like hyperframes_render or hyperframes_snapshot, which have different scopes.

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 does not provide explicit guidance on when to use this tool versus alternatives (e.g., hyperframes_render for full video rendering). It lacks 'when-not' or alternative tool suggestions, leaving the agent to infer based solely on the tool's name and purpose.

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

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

No annotations are provided, so the description carries the burden. It discloses the basic action but omits behavioral traits like side effects, intermediate files, permissions, or error handling. Limited transparency for a tool with no 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 concise with a clear purpose sentence followed by an Args list. It is well-structured and front-loaded, though the example could be integrated more tightly.

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

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

Given the output schema exists, the description adequately covers the tool's purpose and parameters. It explains the combined workflow but could add a brief note on typical usage scenarios or return value format.

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

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

With 0% schema description coverage, the description provides useful parameter semantics: 'absolute path' for project_path, example for post_process, and auto-generated output for output_path. This compensates well but could specify valid ops.

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

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

The description clearly states the tool's specific verb and resource: 'Render a Hyperframes composition and post-process with mcp-video in one step.' This distinguishes it from sibling hyperframes and video tools by combining two operations.

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 (combining two steps) but does not explicitly state when to use this tool versus performing the steps separately. No exclusions or alternatives are mentioned.

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

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

No annotations provided, so description must disclose behavioral traits. It only states functionality without mentioning file size limits, supported formats, destructive actions, or required permissions.

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

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

The description is concise with a single sentence, but it is too terse for a tool with multiple parameters and complexity. It avoids fluff but sacrifices informativeness.

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

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

Despite having an output schema, the description fails to provide sufficient context for correct usage. Lacks details on input formats, output structure, or workflow.

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 0%, yet the description adds no explanation for any of the four parameters. The agent must infer meaning from parameter names only.

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

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

The description clearly states the tool transcribes audio/video to word-level timestamps or imports transcripts. It uses a specific verb and resource, but it does not distinguish from sibling tool video_ai_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?

No guidance on when to use this tool versus alternatives. No context on prerequisites or exclusions.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'generate speech audio or list available Hyperframes local TTS voices' but does not disclose side effects, requirements (e.g., internet, authentication), or behavioral traits like whether generation is synchronous or asynchronous.

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?

Description is a single sentence, concise and to the point. However, it could benefit from structuring the two modes explicitly (e.g., 'Use list_voices=true to list voices, otherwise generate audio from text').

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

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

Given the complexity (6 parameters, no schema descriptions, no annotations), the description is severely incomplete. It does not explain how the tool works, what the output schema contains, or how to switch between generation and listing modes. An output schema exists but its content is unknown.

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 0%, meaning the schema itself has no parameter descriptions. The description does not explain any parameters (e.g., text_or_file, output_path, voice, speed, language, list_voices) or how they relate to the two modes. The agent cannot infer parameter semantics from the description alone.

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

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

Description clearly states two functions: generate speech audio or list voices. Verb-resource pair is specific. However, it does not explicitly distinguish from sibling tools like audio_synthesize, which might also generate audio.

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 usage guidance provided. It does not explain when to use this tool versus alternatives like audio_synthesize, nor does it mention prerequisites or typical use cases.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the tool 'validates' but does not explain what validation entails (e.g., checks for missing files, configuration errors, dependencies). There is no mention of side effects, authentication needs, or output behavior, leaving the agent with insufficient understanding of what happens when the tool is invoked.

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

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

The description is extremely concise: a one-line purpose and a single argument description. Every word contributes value, with no redundancy or filler. The structure front-loads the purpose, making it quickly scannable for an AI agent.

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

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

Despite the existence of an output schema, the description lacks context about the validation process. An agent cannot determine what specific validations are performed, what constitutes 'rendering readiness,' or any prerequisites (e.g., project must exist). The tool's role among workflow steps is unclear, making it less useful for complex decision-making.

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

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

The schema has 0% description coverage, so the description must compensate. It adds useful semantics: 'Absolute path to the Hyperframes project directory,' which clarifies the parameter's nature (absolute path, directory, project-related) beyond the raw schema type 'string'. This is sufficient for correct usage, though more detail (e.g., accepted formats) would be beneficial.

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

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

The description clearly states the tool's purpose: 'Validate a Hyperframes project for rendering readiness.' The verb 'validate' combined with the resource 'Hyperframes project' is specific and unambiguous. The purpose is distinct from sibling tools like hyperframes_render or hyperframes_doctor, making it easy for an agent to select this tool when validation is needed.

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 usage guidelines are provided. The description does not indicate when to use this tool (e.g., before rendering) or when to avoid it (e.g., if you need a different type of check). There is no mention of alternatives among the many sibling tools, leaving the agent without guidance on proper workflow context.

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

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

With no annotations, the description well discloses behavior: extracts dominant colors, optionally uses Claude Vision (requires API key), handles video by extracting a frame, and defaults n_colors to 5. No side effects or destructive actions mentioned, which is appropriate.

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?

Description is concise with a clear summary and structured Args section. A bit verbose but every sentence adds value; could be slightly tighter but well-organized.

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?

Covers main behaviors and parameters; output schema handles return values. Lacks explicit mention of return format (e.g., colors as hex codes) but sufficient given output schema exists. No guidance on prerequisites like image path existence.

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 0%, but description adds full meaning: image_path (absolute path, video handling), use_ai (requires API key), n_colors (default 5). Each parameter explained beyond schema titles/types.

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 it analyzes a product image or video frame to extract colors and optionally generate an AI description. It distinguishes from siblings like image_extract_colors and image_generate_palette by being product-focused and supporting video frames.

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 explicit guidance on when to use vs alternatives (e.g., image_extract_colors for simple color extraction). The description implies product context but doesn't provide when-not or alternative references.

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 fully discloses the algorithm (K-means clustering), output types (hex, RGB, CSS names, percentage), and special case for video files. No missing behavioral traits, though it could mention format limitations.

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

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

The description is concise with clear sections, though the 'Args' block could be integrated into the narrative. No redundant information, and it front-loads the core function.

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

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

Given the output schema (not shown but exists), the description adequately covers inputs and behavior. It addresses video handling and algorithm, though it could note potential file format support.

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

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

The input schema has 0% description coverage, so the description compensates fully. It explains image_path as an absolute path with video handling, and n_colors with range (1-20) and default (5), adding significant value beyond the schema.

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

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

The description clearly states the tool extracts dominant colors from an image or video frame using K-means clustering. It distinguishes itself from sibling tools like image_generate_palette by specifying extraction rather than generation.

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 does not explicitly state when to use this tool versus alternatives like image_generate_palette or analyze_product. It provides minimal context, only hinting at video frame extraction behavior.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that for video inputs a representative frame is extracted, which is helpful. However, it does not disclose whether the tool modifies files, requires permissions, or has any side effects, leaving gaps in transparency.

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

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

The description is concise and well-structured. It begins with a clear purpose statement, then provides parameter details in a bulleted style. Every sentence adds value without unnecessary elaboration.

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

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

Given the presence of an output schema (not shown), the description does not need to detail return values. It covers inputs, behavior for video handling, and harmony types. However, it could mention constraints like supported image formats or file size limits, which are not addressed.

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

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

The schema has no descriptions (0% coverage), so the description's parameter explanations add significant value. It clarifies that image_path is an absolute path, lists the valid harmony types, and explains n_colors. This goes beyond the bare schema types and defaults.

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

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

The description clearly states the tool's purpose: generating a color harmony palette from an image or video frame. It specifies the verb 'generate' and the resource 'palette', and distinguishes it from sibling tools like image_extract_colors by focusing on harmony theory.

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 does not provide guidance on when to use this tool versus alternatives. It lacks context about suitable scenarios, exclusions, or prerequisites, leaving the agent to infer usage from the tool name and purpose alone.

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

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

No annotations are provided, so the description bears the full burden. It states what the tool returns (matching tools with names, descriptions, required parameters) but does not disclose any additional behavioral traits such as rate limits, pagination, or behavior on no matches. This is adequate but not exhaustive.

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

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

The description is concise, consisting of three sentences. It is well-structured with a heading, usage guidance, and a parameter explanation. Every sentence adds value without redundancy.

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

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

Given the simplicity of the tool and the presence of an output schema, the description is complete. It explains the purpose, when to use it, what it returns, and the single parameter. No additional information is necessary for an agent to select and invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by describing the query parameter as a 'Search term' and providing examples ('blur', 'resize', etc.). This clarifies the expected input beyond the schema's type-only definition.

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 that the tool searches registered MCP tools by keyword. It specifies the action (search), the resource (registered MCP tools), and the scope (by keyword). This distinguishes it from sibling tools, which are the actual tools to be searched.

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

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

Explicitly says 'Use this when you need to find the right tool for a task without reading all 91 tool descriptions.' This provides clear context for when to use the tool. It does not explicitly state when not to use it, but the guidance is sufficient for a search tool.

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

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

The description explains the core transformation (expand into prompts) but omits side effects, error handling, or performance characteristics. With no annotations, the agent lacks insight into whether this is read-only, idempotent, or what occurs with invalid inputs.

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

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

The description is a single concise sentence for purpose followed by a bulleted argument list. It is front-loaded, scannable, and contains no superfluous text.

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 purpose and parameters adequately. However, it lacks workflow integration hints (e.g., using storyboard_read prior) and does not address prerequisites or failure modes. Given the output schema exists, return values are acceptable, but completeness for a tool with 2 required params could include more context.

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

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

Despite zero schema description coverage, the description adds critical meaning: project_path must be absolute and contain specific files, shot can be an id or row number. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's action ('Expand one storyboard shot') and resource ('storyboard shot'), yielding specific outputs ('prompt and negative_prompt strings'). It is distinct from sibling tools like storyboard_read, which reads the entire storyboard, and style_pack_read, which reads style files.

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

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

The description provides explicit instructions for each parameter, including required file contents (style.md and storyboard.md) and shot identification format. However, it does not explicitly state when to use this over alternatives or exclude cases (e.g., after reading storyboard with storyboard_read).

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 convey behavioral traits. It states 'Read' implying a safe read-only operation, which is sufficient. However, it does not discuss edge cases, error handling, or any permissions needed, which would improve transparency.

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

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

The description is very concise with two sentences and a parameter list. It is front-loaded with the core purpose, and every sentence adds value. There is no unnecessary information.

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

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

With an output schema available, the description does not need to explain return values. However, it lacks context about prerequisites (e.g., file must exist) and the format of the storyboard table. Given the tool's simplicity, it is minimally adequate but could be more 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 0%, but the description provides detailed meaning for the 'path' parameter, specifying it must be an absolute path to storyboard.md or a directory containing it. This adds critical context beyond the bare 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 the tool reads a PUSHING CREATION storyboard table from a specific file or directory. It provides a specific verb and resource, and distinguishes from sibling tools which are all video/audio processing tools, none of which read storyboards.

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 purpose is clearly defined, but there is no explicit guidance on when not to use this tool or mention of alternatives. However, the sibling list contains no other storyboard read tool, so usage context is implicitly clear.

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 tool reads from a file, but does not mention behavior for missing files, invalid paths, or absence of blocks. The name 'read' suggests non-destructive operation, but additional details would improve transparency.

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

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

The description is extremely concise: two sentences plus a parameter line. It front-loads the purpose and includes necessary detail without any extraneous information. Every sentence serves a purpose.

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

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

Given the output schema exists, the description does not need to explain return values. It covers the input and core functionality. For a simple read tool, it is mostly complete, though it could mention what happens if the file is not found or if no blocks exist.

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

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

The single parameter 'path' is well-documented with the requirement of an absolute path and the acceptable targets (style.md file or directory containing it). This adds significant meaning beyond the schema, which only specifies a string type. While it could include more constraints, it is sufficiently clear.

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

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

The description clearly states the tool reads STYLE_ and NEG_ blocks from a style.md file or project directory. The verb 'Read' and the specific resource distinguish it from siblings, which are all in different domains (audio, video, glitch, etc.).

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 when you need to retrieve style blocks from a style.md file, but it does not provide explicit when/when-not guidance or mention alternatives. Since no sibling tool has similar functionality, the implied context suffices but lacks explicit direction.

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

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

No annotations provided; description does not disclose side effects (e.g., file overwriting, destructive nature), permissions, or failure modes. Only states the action without behavioral context.

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

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

Front-loaded with one-sentence purpose, followed by structured parameter list. Slightly verbose but clear; no wasted sentences.

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

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

Covers all parameters but lacks usage context (e.g., output_path behavior when null, return format). Output schema exists, so return values needn't be detailed here. Missing behavioral and guideline information.

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

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

With 0% schema coverage, description compensates by explaining each parameter (clip1_path, clip2_path, output_path, duration, intensity), including defaults and range (intensity 0-1). Adds meaning beyond schema types.

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

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

Description clearly states 'Apply glitch transition between two video clips', specifying verb, resource, and scope. Distinguishes from sibling transition tools like transition_morph and transition_pixelate.

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 or avoid this tool compared to other transitions. Does not mention prerequisites, ideal use cases, or alternatives among siblings.

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