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 only reveals that this is an additive mutation; it does not explain side effects on existing tracks, whether the operation is reversible, what validation occurs, or what success/failure responses look like.

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 concise and free of filler, but it is not appropriately sized for a tool with 6 parameters and no schema descriptions. It achieves brevity by omitting necessary parameter and behavioral detail, making it under-specified rather than well-structured.

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

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

Given 6 parameters, 2 required fields, 0% schema description coverage, no annotations, and no output schema, a one-line summary is far from complete. An agent cannot reliably know what inputs mean, what the operation will do to the composition, or what outcome to expect.

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

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

Schema description coverage is 0%, and the description provides only minimal high-level context: 'audio track' hints at media_id and 'composition' hints at comp_id. The optional parameters start, duration, trim_start, and volume are entirely unexplained, including their units and how they interact with each other.

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 clear verb and resource ('Add an audio track to the composition') and is not a tautology of the tool name. However, it does not distinguish this from sibling tools like comp_add_clip, audio_mix, or comp_set_audio_mix, so an agent cannot tell whether this creates a new audio track or adds a clip into an existing composition timeline.

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

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

There is no guidance about when to choose audio_add_track over related tools, no mention of prerequisites (e.g., media must already be imported), and no exclusions. The only signal is the tool name and the generic operation, which is insufficient for selecting among the many composition/audio siblings.

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

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

With no annotations, the description carries the burden of disclosing behavior. It clearly states the primary action and output formats, but it does not mention side effects such as file creation, overwriting, output location, return values, or failure conditions when no audio track exists. Core behavior is clear, but operational behavior 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 a single, concise sentence with no filler. It front-loads the action and directly communicates the supported output formats, making it highly efficient for an agent to parse.

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

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

Given the absence of annotations, an output schema, and parameter descriptions, the tool description is not complete enough. It fails to explain the input parameter's type or source, what the tool returns, or any constraints like supported container formats or codec requirements. An agent would likely need additional documentation to call this tool correctly in non-trivial cases.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the format parameter by mapping it to WAV, MP3, and AAC/M4A, which partially overlaps with the enum. However, it does not clarify what the required 'input' parameter refers to—whether it is a file path, media ID, or URL—leaving the main parameter semantically ambiguous.

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, 'Extract', names the exact resource, 'the first audio track', and lists concrete output formats. This clearly distinguishes it from sibling tools like media_extract_frames or audio_mix, making the tool's purpose unambiguous.

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

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

The description implies the tool should be used when a user wants to extract the first audio track and convert it to WAV, MP3, or M4A. However, it provides no explicit guidance on when to choose this over related tools such as audio_add_track, audio_mix, or media_extract_frames, and it does not mention exclusions.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions 'linear gains and offsets' which hints at how it processes audio, but it does not disclose whether this is a destructive write operation, whether it overwrites existing files, or how the output is delivered (file path vs. in-memory). It also does not mention any side effects 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 a single sentence with no filler. It front-loads the primary action and resource, then adds two key behavioral modifiers. Every word earns its place, making it maximally concise and well-structured.

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

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

Given the complexity of a track-mixing tool (nested array, multiple parameters, potential output handling), the description is insufficient. There is no output schema, no annotations, and zero schema description coverage. The description does not explain the semantics of each parameter, the relationship between tracks and duration, or any constraints like maximum track count. An agent would have to guess or infer critical details.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It mentions 'linear gains' (likely volume) and 'offsets in seconds' (likely start), but it does not elaborate on the 'tracks' structure or the 'duration' parameter, nor does it clarify 'trim_start'. This leaves significant gaps for the agent to understand how to correctly specify inputs.

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 ('Mix'), the resource ('audio or video files'), and the output format ('into a WAV'). It also specifies the key operations ('linear gains and offsets in seconds'), which distinguishes it from sibling tools like audio_add_track and audio_extract that serve different purposes.

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

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

The description implies this tool is used for mixing multiple tracks into a single WAV, but it does not explicitly state when to use it versus alternatives like comp_set_audio_mix or provide any exclusions. There is no guidance on prerequisites or conditions that would make this tool the right choice over others.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It conveys that subtitles are visually embedded, but it does not disclose whether the input is modified in place, whether a new output file is created, or what the return value is. No destructive or read-only behavior is 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?

Two short sentences, no filler. The main action is front-loaded and the prerequisite information is given in a second sentence. Every sentence earns its place.

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

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

This is a simple two-parameter tool, but with no output schema and no annotations, the description should at least explain the input/output contract. The agent is left to guess whether the result is written to file, returned, or rendered; the dependency note is useful but does not complete the picture.

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 there are no per-parameter descriptions, so the description must compensate. It adds the useful fact that subtitles can be SRT or ASS, but it never clarifies that 'input' refers to a video file, what formats or paths are expected, or where the burned output goes.

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

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

The description uses a specific verb and resource: 'Burn SRT/ASS subtitles into the picture.' It clearly identifies the action and format scope, and it is distinct from siblings like captions_write_srt or captions_transcribe. It could be stronger by naming a sibling, but the action is unambiguous.

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

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

The second sentence gives environmental context for when the tool can be used (ffmpeg with libass, fonts available in the Docker image), but it does not specify when to choose this over alternatives or when not to use it. Usage is implied by the task description rather than explicitly stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses local execution, no API key needed, model download on first use, and the installation caveat. This is substantive behavioral context, though it does not describe the output format or error behavior.

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

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

The description is succinct, with three sentences that front-load the core action and then add critical constraints. Every sentence carries meaningful information without 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 no annotations, no output schema, and no parameter descriptions in the schema, the description is incomplete. It explains installation and key requirements but fails to clarify what the tool expects (e.g., audio file path) or returns (e.g., transcript text), which an agent needs to call it correctly.

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

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

Schema description coverage is 0%, so the description should compensate by explaining parameters. It does not mention input, model, or language at all, leaving all three parameters undocumented beyond their bare names and types. This is a critical gap.

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

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

The description states a clear verb ('Transcribe') and resource ('Whisper CLI'), indicating the tool performs transcription. It doesn't explicitly distinguish it from sibling tools like captions_write_srt, but the action is unambiguous for a transcription task.

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

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

It gives a condition for use ('if installed') and notes the tool is not in the base image, which hints at an installation prerequisite. However, it does not mention alternatives or scenarios where another tool should be used, leaving usage context partial.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully discloses that no external service or key is required, which is a meaningful behavioral trait. However, it does not explain whether the tool writes a file, returns SRT content, 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?

Two short sentences with no filler. The core purpose is front-loaded and every word 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 there is no output schema and no annotations, the description should clarify what the agent will receive or where the SRT file goes. It does not, so an agent cannot fully predict the call's result or side effects.

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

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

Schema description coverage is 0% and the description does not explain the 'segments' parameter beyond implying subtitle segments. The schema's field names start/end/text and constraints provide some meaning, but units, expected format, and how segments map to SRT cues are left unspecified.

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

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

The description states a specific action and resource: 'Write UTF-8 SRT subtitles.' It is clear and distinct from siblings like captions_burn or captions_transcribe, though it does not explicitly name or contrast them.

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

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

The description implies when to use the tool: whenever SRT subtitle output is needed. 'No external service, no key' hints at a lightweight local operation, but there is no explicit guidance about alternatives or when not to use it.

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

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

With zero annotations, the description carries the full disclosure burden. It does disclose two genuinely informative behaviors: audio is dropped ('video only') and outputs are normalized to a common size/frame rate. But it omits what the tool returns or where output goes, whether input files are modified, and how aspect-ratio mismatches are handled (stretch vs. crop/letterbox).

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

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

A single 12-word sentence that front-loads the core action and compresses the two key qualifiers into subordinate clauses. Every word earns its place, with no filler or repetition of the tool name.

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

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

For a 4-parameter tool with no output schema and no annotations, one sentence is thin. The description never states what artifact the call produces or returns, which an agent needs to chain this with render_start or media_list, and it offers no disambiguation from composition-based sequencing (comp_add_clip) or edge-case behavior for mismatched source resolutions.

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 every parameter is undocumented at the schema level. The description partially compensates by explaining why fps, width, and height exist — they are the normalization target. However, no parameter is individually described, and inputs is only inferable from 'Concatenate videos'; details like aspect-ratio policy or dimension constraints are 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 states a specific verb+resource ('Concatenate videos') with two clarifying qualifiers: '(video only)' and 'normalised to a common size and frame rate.' This makes the operation clear and implicitly sets it apart from audio tools and from simple joining, though it never explicitly names or contrasts any sibling such as comp_add_clip or clip_format_convert.

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

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

The use case is implied: an agent can infer this is the tool for joining multiple video files into a single output. However, there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives — e.g., when concatenation should be preferred over sequencing clips in a composition via comp_add_clip.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does add that the crop happens without scaling, which is useful, but it does not state what happens to the original media, whether the operation mutates the input or creates a new output, what the output format is, or how coordinate origin works. This is a material gap for a media-processing tool.

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

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

The description is a single efficient sentence with no wasted words. It front-loads the core operation and the scaling behavior immediately. It could benefit from more structure, but as a concise statement it is well-formed.

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

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

This tool has 5 parameters, 3 required, no output schema, and no annotations. The description is far too minimal for an agent to invoke it correctly without guessing about input format, return value, coordinate origin, side effects, or relation to sibling media tools. A usable definition would need to specify what input is expected, what the crop does with x/y/width/height, and what output or state change results.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only mentions a 'given rectangle' and 'without scaling,' providing essentially no detail about what input is, what x and y represent, how width and height are interpreted, or what values are valid. The schema provides types and constraints, but the description adds almost no semantic meaning beyond that.

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

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

The description states a specific verb and resource: crop to a given rectangle without scaling. It clearly communicates the spatial nature of the operation and the lack of resizing, which helps distinguish it from temporal operations like clip_trim. However, it does not explicitly identify what 'input' refers to, which leaves some ambiguity.

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

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

The description gives a clear operation but no guidance on when to choose clip_crop over sibling tools. It does not mention that clip_crop is spatial while clip_trim is temporal, nor does it explain when scaling would be needed. No alternatives or exclusion criteria are provided.

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

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

With no annotations, the description must carry behavioral disclosure, but it only states the surface conversion and an 'optional scale and pad' that is not represented in the schema. It omits whether the input is modified, where the output goes, or how padding behaves, making the behavior under-specified and partly misleading.

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

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

The description is a single front-loaded sentence with no filler, and the supported formats are listed compactly. It loses a point because 'pad' is a behavioral claim that is not backed by the schema.

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

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

For a 4-parameter processing tool with no annotations and no output schema, this description is not complete enough. It lacks usage context, parameter details, output location, and behavior on the input file, so an agent would still need to guess key calling conventions.

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, but it only hints at format and scaling without naming the required 'input' or explaining width/height semantics. 'Pad' does not map to any parameter, leaving the parameter model ambiguous.

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 identifies a conversion action with specific target formats (MP4, MOV, MKV, WebM) and optional resizing, which distinguishes it from the clip_* manipulation siblings. It does not explicitly name an alternative tool, but the verb+resource combination is unambiguous.

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

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

There is no indication of when to use this tool instead of clips like clip_crop, clip_speed, or media_import, nor any prerequisites or output expectations. Context must be inferred entirely from the tool name.

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

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

With no annotations, the description must carry the full behavioral disclosure burden. It only states that the tool loops a clip a finite number of times, but does not mention side effects, output behavior, whether the operation is reversible or destructive, or any media-specific implications beyond 'video and audio.' Critical behavioral context 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 a single, focused sentence with no filler or repetition. It states the core operation and the relevant scope (video and audio) efficiently. The most important qualifier, 'finite number of times,' is prominent.

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

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

The tool has two required parameters reasonableness a simple scope, but no output schema and no annotations. A correct invocation depends on knowing what 'input' expects, what the tool returns, and how the looped output is made available. The description is not sufficient for an agent to invoke this tool correctly in a broader 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 description coverage is 0%, so the description must compensate for the lack of parameter documentation. It names 'a finite number of times' which maps to the 'count' parameter but does not define what 'input' is (e.g., a file path, a clip ID, or an asset reference). It also does not clarify whether 'count' includes the original clip or only additional copies. The description adds minimal meaning beyond the raw 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 operation: 'Loop a clip' with the specific qualifier 'a finite number of times (video and audio).' This is a specific verb and resource. It doesn't explicitly distinguish from sibling tools like clip_trim or clip_concat, but the concept of looping is unique within the sibling set.

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

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

No guidance is provided about when to use this tool versus alternatives. It does not mention prerequisites, whether the input should be a file path or a clip ID, or whether it operates in-place or creates a new clip. The usage context must be inferred entirely from the tool name and 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 present, so the description must carry the full burden. It only restates the speed range from the schema, omitting whether the operation is destructive, whether it creates a new clip, or any side effects.

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

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

A single sentence with no waste, front-loading the core action and range. Every word contributes.

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 two unannotated parameters, no output schema, and no annotations, the description is too sparse to fully understand the calling context, expected inputs, or results.

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

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

With 0% schema description coverage, the description must compensate. It adds the speed range, but that duplicates the schema's min/max constraints. It provides no meaning for 'input' (e.g., file path vs. clip ID), leaving a critical parameter unexplained.

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

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

The description states a specific verb ('change') and resource ('video and audio speed'), with a clear speed range. It is easily distinguished from sibling tools like clip_trim, clip_loop, and clip_crop.

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

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

No guidance is given on when to use this tool versus alternatives, nor any prerequisites or context. The agent must infer usage solely from the name and minimal description.

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

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

With no annotations, the description carries the full disclosure burden, and it does add meaningful behavior: it re-encodes rather than stream-copies and uses seconds as the time unit. However, it leaves critical traits undisclosed — whether the operation is destructive, whether it is synchronous or asynchronous, and the fact that re-encoding is compute-intensive.

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?

Five words with the verb front-loaded and zero filler — every token earns its place. It is efficient, though the parenthetical '(seconds)' is overburdened with conveying the time unit for all temporal parameters.

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

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

For a mutation tool with no annotations, no output schema, and 0% schema coverage, this is thin. An agent cannot tell whether the re-encode runs synchronously, what it returns, or whether the original clip is altered, and it barely glosses the meaning of the required `input` parameter.

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 must compensate, but it adds only the '(seconds)' unit hint. It never clarifies what `input` refers to (file path vs. media ID) or that `duration` defines a trim-to-length rather than an end time, even though duration is the sole required length parameter.

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

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

States a specific verb ('Trim') and resource (a clip) with a distinguishing method ('frame-accurate re-encoding'), which separates it from naive cuts and sibling operations like clip_concat, clip_speed, and clip_crop. It does not name a sibling explicitly, so it falls just short of full differentiation.

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

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

No when-to-use guidance or alternatives are provided. The qualifier 'frame-accurate' weakly implies a precision-trimming use case, but there is no exclusion or context routing the agent to, say, clip_concat or a lossless-cut alternative.

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 fully convey behavioral traits. 'Append' implies in-place mutation of the composition, but the description does not disclose whether media must already be imported, what happens to existing timeline content, how `duration` and `in` behave, or whether the operation is reversible.

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

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

The description is a single action-focused sentence with no wasted words. It is concise and front-loaded, though it is so sparse that it misses important invocation detail that could also be conveyed concisely.

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

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

With no annotations, no output schema, 4 parameters, and 0% schema coverage, the description is too thin for reliable invocation. An agent is left without information about how to obtain required IDs, what `in` and `duration` mean, what the tool returns, or what side effects occur.

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 by explaining parameters. It does not: `comp_id`, `media_id`, `duration`, and `in` are left without explanation. The parameter names and types give some signal, but `in` is ambiguous and duration units are never specified.

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

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

The description states a specific action ('Append'), a resource type ('video clip'), and a target ('the composition'). This distinguishes it from clearly different siblings like comp_add_text or comp_add_transition, though it does not explicitly differentiate it from comp_add_overlay or other comp_* 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?

There is no guidance about when to use this tool versus alternatives. With many comp_* and clip_* siblings available, the description provides no context about prerequisites, expected workflow, or when to prefer a different tool.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that overlay video is muted and its last frame is held, which is non-obvious and valuable. However, it does not cover image behavior, z-order, repositioning, or whether adding an overlay overwrites an existing one, so transparency is incomplete.

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 filler. It front-loads the core action ('Add an image or video overlay') and immediately adds a high-value behavioral caveat, making every word earn its place.

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

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

Given 8 parameters, no annotations, no output schema, and zero schema description coverage, this brief description leaves too much unspecified. An agent cannot confidently know coordinate spaces, duration semantics, media source expectations, or what the function returns, so the overall context is incomplete.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain x, y, start, duration, width, height, comp_id, or media_id. It only hints that media_id should reference an image or video, and that duration relates to holding the last frame. Most parameter meanings remain inferred from names rather than documented.

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

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

The description states a specific action and resource: 'Add an image or video overlay', and adds a distinguishing behavioral trait ('overlay video is muted, last frame held'). This clearly separates it from siblings like comp_add_clip and comp_add_text, whose purposes are different even without reading their schemas.

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

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

There is no guidance on when to use this tool versus alternatives such as comp_add_clip or comp_add_text. The description only states what the tool does, leaving the agent to infer selection criteria from the tool name and sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a mutating create operation but does not explain what side effects occur, whether validation is performed, what happens with defaults, or what response is returned. The phrase 'percentage positions' is the only behavioral detail beyond the bare create action.

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

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

The description is a single, front-loaded sentence with no wasted words. It places the core action first and adds the key distinguishing qualifier at the end, making it easy to parse. However, given the tool's parameter count and sibling set, the brevity borders on under-specification rather than disciplined conciseness.

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

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

For a tool with 12 parameters, no annotations, and no output schema, this description is incomplete. It does not mention prerequisites like an existing comp_id, how timing values are interpreted, what defaults apply, or what the tool returns after adding the text overlay. The one-sentence summary leaves too much for the agent to infer from names and schema constraints.

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 must compensate for the 12 undocumented parameters. 'Percentage positions' clarifies the meaning of x_pct and y_pct, but it does nothing for comp_id, text, start, duration, color, align, font_family, font_size_px, w_pct, or bg_color. The bulk of the parameter semantics remain implicit in property names 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 states a specific action and resource: 'Add a text overlay', which clearly distinguishes this from generic overlay tools like comp_add_overlay and clip manipulation tools. The qualifier 'with percentage positions' adds a meaningful scope detail that helps identify the intended coordinate system, though it does not explicitly name any sibling tool.

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

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

No guidance is given about when to use this tool versus comp_add_overlay, comp_update_text, captions_write_srt, or other text-related tools. There are no context cues about prerequisites, such as the composition needing to exist, and 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?

With no annotations, the description carries the transparency burden. It does disclose the core visible behavior and guarantees no overlap or duration change, which is genuinely useful. However, it omits side effects such as whether an existing transition is replaced, whether audio is affected, and whether the operation is reversible, so the disclosure is partial.

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 filler. The core behavior is front-loaded, and the caveats ('no overlap', 'no change in duration', 'not a crossfade') are packed efficiently without repeating schema information.

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

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

For a tool with no annotations, no output schema, and four schema parameters at 0% description coverage, this description is incomplete. An agent cannot determine what after_clip_id refers to, what units duration uses, or what the tool returns. The behavioral description is clear, but the operational details needed to invoke the tool correctly are missing.

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

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

The schema has 0% description coverage, so the description needed to explain comp_id, after_clip_id, duration, and type. It does not do this: after_clip_id placement, duration units, and the fixed fade_black type are all left implicit. The phrase 'no change in duration' is a behavioral statement, not an explanation of the duration parameter.

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

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

The description specifies the transition effect ('fade to black then back') and key constraints ('no overlap', 'no change in duration'), making it clear this is a dip-to-black transition rather than a crossfade. It relies on the tool name for the 'add transition' action, so it is clear but not fully self-contained and does not explicitly differentiate it from sibling add tools like comp_add_clip or comp_add_overlay.

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

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

The 'Not a crossfade' statement is a useful exclusion, and the no-overlap/no-duration-change constraints suggest where and how the transition should be placed. However, there is no explicit statement of when to prefer this tool over alternatives or what preconditions must hold, such as adjacent clips or a valid composition. Usage guidance is only implied by the transition description.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add useful context by stating the composition is stored locally as JSON and involves no API or database, which clarifies persistence and side effects. However, it does not disclose what happens on overwrite, permissions needed, or what the tool returns.

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

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

The description is extremely concise with no filler. Both sentences add distinct value: the first defines the action and resource, the second clarifies the storage and side-effect profile. It is appropriately front-loaded.

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

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

The tool is simple, but the description omits essential usage context: there is no mention of return values, resource IDs, how the composition is referenced by sibling tools, or the relationship between 'name' and the local JSON file. Without an output schema, the agent lacks critical information about what to do after calling this tool.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings or usage. It provides no information about 'name', 'width', 'height', or 'fps', leaving the agent to rely solely on schema defaults and constraints.

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 'Create' and the resource 'a sequential composition', and adds meaningful storage details ('stored locally as JSON'). It does not explicitly differentiate from sibling tools like comp_add_clip or comp_add_overlay, but the creation-action is distinct enough for an agent to infer the tool's core 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?

There is no guidance on when to use this tool versus alternatives, and no mention of prerequisites or ordering relative to sibling tools like comp_add_clip or comp_get_timeline. The 'No API, no database' statement describes behavior rather than usage context.

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

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

With no annotations provided, the description carries the burden of indicating safety. The verb 'Read' implies a non-destructive operation, which is useful, but the description does not mention error behavior, permissions, or what happens for invalid/missing comp_id.

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

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

The description is a single concise sentence with no wasted words. It is front-loaded with the core action and resource, though it is perhaps too terse to cover important usage details.

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

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

For a simple getter with one parameter, the description names the primary return values (composition JSON and total duration), and there is no output schema to add detail. However, with no annotations, no output schema, and no sibling differentiation, the description leaves some operational context unstated.

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

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

The schema has 0% description coverage and the description does not mention comp_id at all. The parameter name is somewhat self-explanatory, but the description fails to clarify the relationship between comp_id and the returned composition JSON, so it does not compensate for the low schema coverage.

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

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

The description states a specific action ('Read') and a clear resource ('the composition JSON') plus an additional returned value ('total duration'). It distinguishes this tool from the many comp_* mutation/validation siblings, though it does not explicitly name an alternative.

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

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

No guidance is provided about when to use this tool instead of other composition-related tools such as comp_validate or comp_create. The description only says what it does, not the conditions or context in which it is the right choice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action (remove) but does not disclose side effects, such as whether the removal is permanent, whether it affects the composition timeline, whether it requires the composition to be in a certain state, or what happens if the text_id does not exist. For a mutating operation, this is a significant gap.

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

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

The description is a single short sentence with no wasted words. It is front-loaded with the action and object. However, it is so brief that it sacrifices useful context, though conciseness itself is good.

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

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

For a mutating tool with no annotations, no output schema, and 0% schema description coverage, the description is too thin. It does not explain the effect on the composition, error conditions, or any state requirements. An agent would need to guess or rely on external knowledge to call this tool correctly in a real 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 description coverage is 0%, so the description must compensate. It mentions 'identifier' but does not explain that comp_id identifies the composition and text_id identifies the text overlay, nor does it clarify the relationship between the two parameters. The schema itself only provides types and a $ref, which is minimal. The description adds almost no parameter-level 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 states a specific verb ('Remove') and resource ('text overlay'), and identifies the object by 'identifier'. It is clear about what the tool does. However, it does not explicitly distinguish it from sibling tools like comp_add_text or comp_update_text, though the verb 'remove' makes the distinction fairly obvious.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of prerequisites (e.g., the composition must exist, the text overlay must exist), no exclusions, and no reference to sibling tools. The agent must infer usage from the name and 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?

With no annotations provided, the description carries full responsibility for disclosing behavior. It states 'replace' implying mutation, but does not explain side effects, reversibility, permission requirements, or what happens to the existing mix. It offers minimal behavioral transparency beyond the verb.

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

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

The description is a single short sentence, but it is under-specified rather than appropriately concise. It lacks the detail needed to be useful; the brevity does not contribute to clarity, only to inadequacy.

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 3 parameters (including a complex 'tracks' array), no output schema, and no annotations, this description is severely incomplete. It fails to explain what an 'audio mix' constitutes, how the tracks array is structured, or any expected behavior. An agent would have to guess almost everything.

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 by explaining parameters. It does not mention tracks, comp_id, or original_volume at all. The agent receives no additional meaning beyond the raw schema, which is already opaque for nested objects like 'tracks'.

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

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

The description uses a specific verb ('replace') and names the exact resource ('audio mix of a composition'). This clearly differentiates it from siblings like audio_mix, audio_add_track, or comp_add_clip, leaving no ambiguity about what the tool operates on.

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. It does not mention distinctions from audio_mix, audio_add_track, or other composition-related tools, nor any prerequisites or typical scenarios.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does disclose the partial-update behavior ('only supplied fields'), which is valuable. However, it doesn't disclose whether the update is destructive to unspecified fields (it implies it isn't), whether it requires the comp to be in a certain state, or what happens if the text_id doesn't exist. The description is honest but minimal.

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

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

The description is a single, efficient sentence that front-loads the key behavior ('Update only supplied fields') before naming the resource. Every word earns its place, and there's no fluff. It could arguably add more detail, but for what it says, it's concise and well-structured.

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

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

For a tool with 13 parameters, 0% schema description coverage, no annotations, and no output schema, the description is far too thin. An agent would not know what fields are available, what the defaults mean, how the positioning fields (x_pct, y_pct, w_pct) interact, or what the return value looks like. The partial-update behavior is helpful, but the overall context is incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the 13 parameters. It does not. The description only says 'supplied fields' without listing or explaining any of the parameters (text, align, color, start, w_pct, x_pct, y_pct, bg_color, duration, font_family, font_size_px). The schema provides types and defaults, but the description adds no semantic meaning about what these fields do or how they relate to each other.

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 'Update only supplied fields of a text overlay' clearly identifies the verb (update), the resource (text overlay), and the key behavioral nuance (only supplied fields are updated, implying a partial update rather than a full replacement). It distinguishes itself from comp_add_text (which creates) and comp_remove_text (which deletes), though it doesn't explicitly name those siblings.

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

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

The description implies usage context: it's for updating an existing text overlay, and the 'only supplied fields' phrasing signals that omitted fields are preserved. However, it doesn't explicitly state when to use this tool versus comp_add_text or comp_remove_text, nor does it mention any prerequisites like the overlay needing to exist or the comp needing to be valid.

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 responsibility for disclosing behavior. It lists what gets validated but does not state whether the operation is read-only, what happens when validation fails, whether errors are returned or thrown, or what the output/result looks like. This is a significant gap for a validation tool an agent may rely on to decide whether rendering should proceed.

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

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

The description is a single front-loaded sentence with no filler words. It efficiently communicates the tool's scope and timing context, though this brevity comes at the cost of behavioral detail.

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

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

With no annotations, no output schema, and only one under-described parameter, the description should provide more operational context. It does not explain the validation result format, error behavior, side effects, or prerequisites, leaving an agent unable to fully anticipate the tool's response.

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 needed to compensate, but it does not mention comp_id or how it is used. The schema itself gives comp_id a UUID format, making the single parameter somewhat self-explanatory, but the description adds no semantic value beyond the structured input schema.

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

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

The description states a specific verb ('validate') and domain ('references, time ranges, transitions and media') tied to a composition context, which is enough to identify the tool's purpose. It does not explicitly say 'composition,' but the comp_ prefix and editing-related terms make the resource clear. No sibling tool duplicates this validation function, so differentiation is not an issue.

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

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

The phrase 'before rendering' provides clear contextual guidance on when to call this tool: prior to starting a render. It does not explicitly name alternatives or exclusions, but there is no direct sibling alternative for validation, so the timing guidance is sufficient for basic routing.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It does disclose the 'centred cover crop' behavior, but it doesn't state whether an export creates a file, triggers an async render, requires authentication, or what the response contains.

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

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

The description is compact and front-loads the listing action. The semicolon construction is a bit awkward, but the text wastes few words and conveys the dominant behavior quickly.

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

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

With no annotations, no output schema, and a 0% description coverage in the schema, the description leaves critical gaps: return format, input semantics, output destination, and how this relates to sibling export tools. It is functional but incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description should compensate. It indicates that 'input' is the thing to be exported and that 'format' relates to aspect ratios, but it doesn't define what input values are valid (e.g., media id, file path) or how format maps to the crop behavior.

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

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

The description states two clear behaviors: listing aspect ratios and exporting an input with a centred cover crop. It names the resource ('aspect ratios') and the action ('export'), though it doesn't explicitly distinguish from sibling export tools such as export_gif or export_thumbnail_set.

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

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

There is no direct guidance on when to use this tool versus export_gif, export_thumbnail_set, or render_get_output. The two mode condition is only implied by 'with an input' versus without one, and 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?

With no annotations provided, the description must carry the behavioral burden. It mentions the 30-second max duration and optimized palette, but fails to disclose side effects, output location, post-processing behavior, or any potential blocking/long-running nature. The description gives minimal behavioral context for a file-export operation.

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

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

The description is a single, front-loaded sentence that conveys the core purpose and a key constraint without waste. It is appropriately concise for the tool's simple purpose, though it sacrifices important details.

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

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

For a tool with five parameters, no annotations, and no output schema, the description leaves critical gaps: what the 'input' should be, where the output goes, how to retrieve it, and any side effects. The sibling context suggests a media pipeline, but the description alone is insufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the five undocumented parameters. It only hints at '30 seconds max' (matching the duration limit) and 'excerpt' (implying start/duration), but does not explain fps, width, or the input string format. This adds marginal value over the raw 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 exports a GIF excerpt with an optimized palette, using a specific verb and resource. It does not explicitly differentiate from siblings like media_extract_frames or clip_format_convert, but the purpose is unambiguous enough for an agent to identify it.

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 such as clip_format_convert or render_start. There is no mention of prerequisites, input media requirements, or scenarios where a different export format would be preferred.

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 indicates a write operation but does not state whether it overwrites existing files, where the output file is written, what the return value is, or whether any side effects occur. The absence of such details is a significant gap 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 a single, concise sentence with no wasted words. It is front-loaded with the primary action. However, its brevity comes at the cost of essential context, so it is not overly efficient in conveying necessary information.

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

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

Given the lack of annotations, output schema, and parameter documentation, the description is insufficient for an agent to correctly invoke the tool. It does not clarify the output file path, return value, or relationship to other media tools. The tool is simple but still requires more contextual detail to be considered complete.

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

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

The schema has one required string parameter 'input' with 0% description coverage, and the tool description does not explain the parameter's meaning. It is unclear whether 'input' is the source media file path, the output JSON path, or something else. This is a critical omission for a single-parameter tool.

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

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

The description states a clear verb ('Write') and resource ('ffprobe metadata') and specifies the output form ('local JSON file'). This distinguishes it from sibling tools like media_probe, which focuses on probing, and export_formats, which likely converts formats. However, it doesn't explicitly differentiate or clarify what 'ffprobe metadata' refers to, leaving slight ambiguity about the source of the metadata.

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. There is no mention of prerequisites, such as needing to run a probe first with media_probe, or comparison to other export tools like export_gif or export_thumbnail_set. The description fails to route the agent to the appropriate context.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It reveals a center-of-interval sampling rule, but does not state whether the operation is read-only, whether it writes files, or what it returns. The word 'export' hints at side effects, but this is left ambiguous.

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

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

The description is a single efficient sentence with no filler or redundant information. However, it is so terse that it omits usage details an agent would need.

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

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

For a 3-parameter tool with no annotations, no output schema, and no parameter descriptions, this is incomplete. The core operation is intelligible, but return format, side effects, and parameter meanings are all absent.

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 and no parameter information in the description, none of 'input', 'count', or 'width' are given meaningful semantics. The schema supplies only types, defaults, and bounds, so an agent cannot infer whether 'count' means number of thumbnails or number of intervals.

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

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

The description gives a concrete verb ('extract') and resource ('a set of thumbnails'), and adds a distinctive sampling rule ('one at the centre of each interval'), so an agent can differentiate it from a single-thumbnail tool. It stops short of explicitly distinguishing it from siblings like export_gif or media_extract_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?

There is no guidance on when to use this tool versus alternatives. It does not mention when to choose it over media_thumbnail, media_extract_frames, or export_gif, and it never clarifies the source media or context in which intervals apply.

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 implies a file-writing mutation ('Copy or download... into a new local file') but doesn't disclose overwrite behavior, error conditions when the generation isn't complete, whether the backend changes behavior, or file-system permissions required. The 'new local file' phrasing weakly implies it creates rather than overwrites, but this is not explicit.

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

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

A single, tight sentence with zero filler and the primary action front-loaded. Every word earns its place; there is nothing redundant to trim.

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

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

For a 3-parameter tool with 0% schema coverage, no annotations, and no output schema, this description is under-specified. An agent cannot determine what id to pass, which backend to select, or what destination format is expected. The unexplained 'backend' enum is especially problematic since choosing local vs azure-sora materially changes execution.

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 for the undocumented parameters — and it doesn't. It never explains that 'id' is the generation identifier to fetch, what 'backend' (local vs azure-sora) controls, or the expected format of 'destination'. The description adds no semantic value 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 states a clear verb ('Copy or download') and resource ('the finished result') with a destination ('a new local file'). It's tied to the generation workflow, which distinguishes it from render_* and other siblings. However, it doesn't explicitly name sibling alternatives, and 'finished result' is somewhat ambiguous about what entity it refers to (a shot, a render, a media asset).

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. It doesn't say to call it after generate_status reports completion, nor does it contrast with render_get_output, which could plausibly serve a similar 'get the result' role. No prerequisites or sequencing hints are provided.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It gives a minimal hint about backend selection (local default vs. Azure Sora) but does not describe what the tool does to the input, whether it returns a result immediately or asynchronously, side effects, or required authentication for Azure. This is a significant gap for a generation 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 short, but it is not effectively concise because it is vague and does not convey the tool's core function. It front-loads the backend choice but omits essential information, making it more of an under-specification than a concise statement.

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 no output schema, the description is severely incomplete. It does not explain the purpose, the input parameters, the workflow, or the expected outcome. An agent cannot correctly invoke this tool based on the provided description alone.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It does not mention any of the five parameters (size, prompt, source, backend, seconds) or their meanings. The tool's behavior with these parameters is entirely undocumented, making it impossible for an agent to know how to set them correctly.

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 does not clearly state that this tool generates a video shot. It mentions 'Prepare an existing local rush' and 'call Azure Sora', but the core action of generating a shot is only implied by the tool name. There is no specific verb+resource statement, and it does not distinguish itself from sibling tools like generate_status or generate_fetch.

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

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

There is no guidance on when to use this tool versus alternatives. The mention of 'default' and 'explicitly call Azure Sora' hints at backend choice, but it does not explain when to pick local vs. Azure Sora, nor does it differentiate from other generation-related tools.

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

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

With no annotations, the description must carry the behavioral burden. It does disclose one useful trait: the backend is recovered from local metadata, so the backend parameter may be redundant. However, it does not state whether the operation is read-only or describe how the returned state is represented.

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 compact sentence with no filler, and the core resource ('generation job state') is front-loaded. It is concise, though the lack of an explicit verb makes the structure slightly elliptical.

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 status tool with no output schema, the description does not explain what the returned state contains, what possible states exist, or how the backend parameter interacts with the local metadata. It leaves an agent with enough to guess, but not enough to call it with full confidence.

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 needed to compensate. It only partially explains the backend parameter (recovered from local metadata) and says nothing about the required id parameter or how it is used to locate the generation job.

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

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

The description identifies the resource ('a generation job') and conveys that the tool reports its state, but it lacks an explicit verb such as 'get' or 'returns' and does not distinguish generate_status from sibling tools like generate_fetch or render_status. The backend-metadata clause is an implementation detail rather than a purpose statement.

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

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

There is no guidance on when to call this tool instead of generate_fetch, render_status, or other status-related tools. The only hint is that the backend is recovered from local metadata, which implies callers do not need to supply it, but this is not stated as a usage rule.

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

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

With no annotations provided, the description must disclose behavioral traits. It mentions what is checked (binaries, codecs, filters, write access) and that it reports backends, implying a read-only diagnostic. However, it does not explicitly state that the tool has no side effects, nor does it describe any potential errors or the nature of the 'report' (e.g., format, verbosity). This is adequate but lacks explicit safety guarantees.

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 filler. The primary action ('Check') and key subjects are front-loaded, and the clause about reporting backends adds necessary scope without unnecessary detail. It is perfectly sized for a no-parameter diagnostic tool.

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

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

For a no-parameter tool, the description is mostly complete for invocation. However, it lacks details about the output format of the 'report' (e.g., JSON, plain text) and any possible failure modes (e.g., missing binaries causing errors). Since there is no output schema and no annotations, the description should hint at the return structure to help an agent interpret the result. This gap prevents a higher score.

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

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

The tool has zero parameters, so schema coverage is trivially complete. The baseline for zero-parameter tools is 4, and the description adds context by specifying the scope of the check (binaries, codecs, filters, write access, backends), which is meaningful beyond the empty 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's purpose with a specific verb 'Check' and enumerates the resources examined: binaries, codecs, filters, and local write access. It also mentions reporting configured backends. This is unambiguous and easily distinguishable from any sibling tool, none of which perform environment diagnostics.

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 is given on when to use this tool versus alternatives. Since none of the siblings appear to offer a similar health-check function, the need for differentiation is low. However, the description does not state any prerequisites or typical invocation scenarios (e.g., 'run before media operations'), leaving usage timing to inference.

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

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

With no annotations and no output schema, the description carries the full burden, but it only restates the 300-count maximum already present in the schema. It does not disclose whether extracted frames are returned, written to storage, or what other side effects or limits apply.

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

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

The description is a single front-loaded sentence with no fluff. It loses a point because '(300 max)' repeats the count maximum already present in the schema rather than adding new information.

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

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

For a five-parameter tool with no annotations and no output schema, this is thin: an agent cannot infer units for interval/start, what the output looks like, or how this relates to sibling extraction/thumbnail tools.

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

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

Schema description coverage is 0%, so the description must compensate, but it only hints at 'interval' and the 300 count limit. The semantics of media_id, start, and width are left entirely to parameter names 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 identifies a specific operation ('Extract frames') on media, and 'at a fixed interval' distinguishes it from one-off thumbnail tools. The parenthetical '300 max' is slightly ambiguous (max count vs. interval), and no sibling tool is named, so it does not fully differentiate among media_thumbnail, export_gif, and export_thumbnail_set.

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

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

No guidance is given about when to choose this over alternatives such as media_thumbnail, export_thumbnail_set, or export_gif. The fixed-interval phrasing implies regular sampling, but the description contains no explicit context or exclusions.

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

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

With no annotations provided, the description carries the full behavioral burden. It accurately discloses that this is a copy/mutation operation and states source types and destination, but it does not explain overwrite behavior, how the optional name affects storage, or what the operation returns.

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

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

The description is a single sentence with no filler. It front-loads the action and resource, and every clause contributes useful information about the source or destination.

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

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

For a simple two-parameter tool, the core action and source semantics are covered, but the `name` parameter and expected result are left unspecified. Given no annotations and no output schema, a bit more detail about naming and return value would make it 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 compensate. The narrative explains `source` by specifying local file or HTTP(S) URL, but it never mentions the optional `name` parameter or its role, leaving a meaningful gap in a two-parameter tool.

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

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

The description opens with a specific verb, 'Copy', and identifies the resource, the local media store, plus the accepted source forms. This clearly distinguishes it from sibling tools like media_list and media_probe, which are read-oriented.

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

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

The description implies when to use the tool: when media needs to be brought into the local media store. However, it gives no explicit when-not-to-use guidance and does not mention alternatives, so the usage context is implied rather than fully specified.

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. 'List imported media' implies a read-only operation, but it does not state whether the list is paginated, sorted, or limited to a particular project/workspace, nor does it describe the return format. The description is too thin to give an agent confidence about the tool's behavior.

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

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

The description is a single short sentence with no wasted words. It is front-loaded with the verb and resource. It earns a 4 rather than 5 because it is so terse that it omits useful context, but as a concise statement it is efficient.

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

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

For a simple parameterless list tool, the description is minimally adequate, but it lacks any detail about the output shape, ordering, or scope of the list. With no output schema and no annotations, an agent cannot know what fields will be returned or whether the list is global or scoped. Given the tool's simplicity, a 2 reflects the missing behavioral and output context.

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

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

The tool has zero parameters, so there is no parameter semantics burden on the description. The schema is empty and fully covered, and the description correctly implies that no arguments are needed. A baseline of 4 is appropriate for a parameterless tool.

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

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

The description 'List imported media' has a clear verb and resource, so an agent can tell it is a read-only listing operation. However, it does not distinguish itself from sibling tools like media_thumbnail or media_probe, which also operate on media, so the purpose is clear but not differentiated.

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

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

No guidance is given about when to use this tool versus alternatives such as media_probe or media_thumbnail. The description implies a simple listing use case but provides no exclusions or context about what kind of media is listed or how it relates to the import 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 are present, so the description carries the full transparency burden. Mentioning ffprobe hints at a read-only inspection, but the description does not disclose whether the file is modified, what output format is returned, or how errors/failures behave.

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

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

The description is a single, direct sentence with no filler. Every word contributes meaning, and the core action and target are front-loaded.

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

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

For a tool with no output schema and no annotations, the description is too thin. An agent knows to pass media_id but cannot predict what the tool returns, whether it is safe/read-only, or how it relates to the broader media workflow. More context is needed for confident selection and invocation.

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

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

There is one required parameter, media_id, with 0% schema description coverage. The phrase 'a media file' adds some context that media_id refers to the file being probed, and the name media_id plus uuid format is fairly self-explanatory, but the description does not explain how to obtain a valid media_id.

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

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

The description states a specific action, 'Probe', and a resource, 'a media file', and names ffprobe, a well-known metadata inspection utility. This distinguishes it from siblings like media_import or media_list, though it stops short of explicitly saying it returns format/stream metadata.

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, what prerequisites exist, or where media_id comes from. The verb 'probe' implicitly suggests inspecting an already imported file, but no explicit usage context 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 the full burden of behavioral disclosure, but it only reveals that the output is a single JPEG. It does not state the return format (binary, URL, or base64), the unit or semantics of `at`, or behavior on invalid media, leaving the agent to guess how a successful call is delivered.

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 efficient with zero waste, but the brevity reflects under-specification rather than disciplined, front-loaded structure. At 0% schema coverage, the description cannot afford to be this spare.

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

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

For a 3-parameter tool with no annotations and no output schema, this description leaves essential invocation details unanswered: how the JPEG is delivered, what `at` means, and how width constraints affect the result. It is barely sufficient for an agent to call the tool correctly and safely.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented `media_id`, `at`, and `width` parameters, yet it is completely silent on all three. An agent cannot learn what `at` controls, in what units, or how `width` is applied (aspect-ratio preservation vs. cropping) from either the schema or the description.

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

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

The description uses a specific verb ('extract') with a specific resource ('a single JPEG thumbnail') and names the output format, making the core operation clear. However, it does not explicitly distinguish it from siblings like `media_extract_frames` and `export_thumbnail_set`; the word 'single' only implies the contrast rather than stating it.

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

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

The description gives no guidance on when to use this tool versus alternatives. It never mentions `media_extract_frames` for multiple frames or `export_thumbnail_set` for a set of thumbnails, and provides no use-case context such as previews or contact sheets. An agent must infer appropriateness purely from the tool name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It transparently signals destructive behavior via 'kill,' and it distinguishes between canceling a queued job and killing a running process. However, it does not disclose consequences like whether partial output is cleaned up, whether cancellation is idempotent, or what error occurs for an unknown job_id.

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

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

The description is two short clauses with no filler. Every word contributes meaning: the action, the object, and the two distinct operational states are all front-loaded and immediately scannable.

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

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

For a single-parameter cancellation tool, the description is nearly complete. It tells the agent what the tool does and which state it affects. The main gaps are return/error behavior and job_id provenance, but the simplicity of the tool makes those less critical; there is no output schema to complicate interpretation.

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 description coverage is 0%, so the description should compensate by explaining the parameter. It never mentions job_id or where to obtain it (e.g., from render_start), leaving the parameter's meaning almost entirely to inference from the tool name and 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 uses a specific action verb ('Cancel'/'kill') with a concrete resource ('a queued job'/'its running ffmpeg'), clearly differentiating render_cancel from render_start, render_status, and render_history. The queued-vs-running distinction adds useful precision.

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

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

The description implies when to use the tool: when a job is queued and should be canceled, or when it is running and its ffmpeg process should be killed. However, it does not explicitly name alternatives or state exclusions, such as what to do for already-completed jobs, so an agent must infer the routing from sibling names.

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 correctly conveys a non-mutating read operation, but it does not disclose behavior for unfinished/failed jobs, error handling, or whether the path is guaranteed to exist.

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

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

A single front-loaded sentence with no filler. Every word contributes to understanding what the tool returns.

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

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

For a simple one-parameter getter, the purpose and return value are stated, but the description lacks explicit call timing and error behavior. An agent could mistakenly call it before the render has finished.

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

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

The schema has zero descriptive coverage and the description never mentions job_id or how to obtain it. The property name and uuid format are somewhat self-evident, but the description adds no 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?

States a concrete verb and resource: return the path of a finished MP4. This clearly distinguishes it from sibling render lifecycle tools like render_start, render_status, and render_cancel.

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 word 'finished' implies the tool should be used only after a render is complete, but it does not explicitly mention checking render_status first or say when not to use it. Guidance is inferred rather than explicit.

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

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

With no annotations provided, the description carries the full behavioral burden, but it only states durability and ordering. It does not disclose whether in-progress or failed renders are included, what fields each entry contains, or anything about permissions or response shape.

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

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

One short sentence with no filler; the resource, ordering, and durability trait are all front-loaded. Every word earns its place.

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

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

For a simple tool with one optional parameter, this is nearly adequate: an agent can invoke it safely with no args or with a limit. However, with no output schema, the description does not explain what a history entry contains or how to correlate entries with other render 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 single `limit` parameter is fully constrained in the schema with type, default, minimum, and maximum. The phrase 'most recent first' gives it contextual meaning as limiting the number of recent history entries returned, even though the description does not mention the parameter directly.

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?

Identifies the resource ('render history') and a key ordering trait ('most recent first'), making it distinguishable from render_status or render_get_output. It lacks an explicit verb like 'list' or 'get', but the intent is clear from the name and wording.

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

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

No guidance is given on when to use this tool versus render_status, render_get_output, or other render-related siblings. The word 'history' implies a past-facing view, but the description never states this explicitly or names alternatives.

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

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

With no annotations, the description itself must disclose behavior. It does provide meaningful behavior: the render is asynchronous, local, based on a durable JSON snapshot, and restarts from the beginning if interrupted. This goes beyond a generic tool description, though it omits details like return values, cancellation behavior, and whether an existing render is replaced.

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

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

The description is compact and front-loaded, with the main action stated first. Every sentence adds information: 'asynchronous local render' sets the core behavior, and the durable snapshot/restart note is valuable context. There is no redundancy or filler.

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

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

For a tool that starts an asynchronous process, the description does not state what the call returns or how an agent should later retrieve the render result (e.g., via render_status or render_get_output). It covers the start semantics and interruption behavior, but lacks the return-value and follow-up context needed to use the tool end-to-end.

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 one required parameter, comp_id (a UUID), but the description provides no additional meaning for it. With schema description coverage at 0%, the description should compensate by clarifying that comp_id identifies the composition to render, but it does not. The parameter name is somewhat self-explanatory, but the description adds no semantic 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 uses a specific verb and resource: 'Start an asynchronous local render.' It clearly states the action and object, and the 'async' qualifier helps set expectations. However, it does not explicitly distinguish itself from related sibling tools like render_status or render_cancel, so the differentiation is only implicit.

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

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

The description implies when to use this tool: when you want to begin a render. It also implies that the render is asynchronous, which suggests pairing with status-checking tools. However, it does not explicitly name alternatives or state when not to use it, leaving the usage decision mostly to inference.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It only mentions that there is no estimated percentage, which is a small behavioral detail, but fails to state whether the tool is read-only, what it returns, or any error conditions. This is insufficient for an agent to predict its behavior.

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

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

The description is extremely short and has no wasted words, but it is under-specified. It front-loads the phrase 'Persisted render state,' but that phrase is not a clear action statement. Conciseness is achieved at the expense of clarity, making this an average effort.

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 one parameter, no output schema, and no annotations, the description is far too thin. It does not explain what action is performed, what the response contains, or how it relates to the render lifecycle. An agent would not be able to call this tool correctly based on the provided text.

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

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

Schema description coverage is 0% and the description provides no explanation of the job_id parameter or how it is used. The parameter itself is a UUID and somewhat self-explanatory, but the description adds zero semantic value beyond the raw schema, so it fails to compensate for the coverage gap.

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

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

The description 'Persisted render state (no estimated percentage)' identifies the resource (render state) but uses a noun phrase rather than a clear verb like 'retrieve' or 'get'. It gives some idea of the tool's purpose but is vague and does not distinguish it from siblings like render_history or render_get_output.

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

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

There is no guidance on when to use this tool versus alternatives such as render_history or render_get_output. The description offers no context about the appropriate use case, leaving the agent to infer from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state the expected outputs (masks and JSONL track), but it does not mention side effects, file writes, speed, failure modes, or processing lifetime, which is significant for a tracking 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 very short and free of filler, and it front-loads the core output concept. However, it is closer to an under-specified fragment than a useful tool contract, and the brevity comes at the expense of essential context.

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

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

For a tool with six parameters, no output schema, and no annotations, the description is far too sparse. It does not explain the role of point prompts, labels, blur/erosion parameters, or what input/output paths mean, so an agent cannot confidently 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%, and the description adds no meaning to input, output, points, labels, blur, or erosion. Since the schema itself only provides types and constraints, an agent has no semantic basis for choosing correct parameter values.

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

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

The description clearly identifies the tool's output artifacts (masks plus a JSONL track with boxes and centroids) and narrows scope to a single object. It is not a tautology and is more informative than a bare name, though it lacks an explicit action verb and does not name sibling tools for contrast.

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

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

No guidance is given on when to use this tool versus alternatives such as sam2_segment_video, sam2_propagate_mask, or sam2_refine_mask. The phrase 'for one object' weakly implies a single-object use case, but there is no explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It reveals that propagation is approximate and driven by sampled inside/outside points, but it does not disclose side effects, prerequisites, output behavior, or whether the operation is read-only or mutating.

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 filler, but the phrasing is cryptic and compresses essential meaning at the expense of clarity. It is concise rather than well-structured.

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

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

For a tool with five parameters, no schema descriptions, and no output schema, this is too sparse: the input/output contract, optional parameters, and expected result are absent. Only someone already familiar with SAM2 tooling could call this 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%, and the description only loosely relates mask to an 'initial mask' and inside/outside point sampling. It does not explain input, output, blur, or erosion, leaving even required parameters semantically opaque.

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

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

The description names the operation ('propagation'), the model ('SAM2'), and a distinctive detail ('from inside/outside points sampled in the initial mask'), which helps distinguish it from sibling segmentation and refinement tools. It is still terse and does not explicitly state what the propagated output is or whether it applies across 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 guidance is provided on when to choose this tool over alternatives like sam2_object_track, sam2_refine_mask, or sam2_video_inpaint. The word 'approximate' hints at a quality tradeoff, but no conditions 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 are provided, so the description carries the full burden. It discloses the operations (erosion, Gaussian blur) and the dependency requirement, but it doesn't state whether the input mask is modified in-place, whether the output file is overwritten, what happens with existing files, or any side effects. For a tool that writes an output file, this is a significant gap.

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

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

The description is a single sentence, concise and front-loaded with the core action. The dependency note is useful but could be considered extra. No wasted words, though it could be slightly more informative 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?

For a tool with 4 parameters, 0% schema coverage, no annotations, and no output schema, the description is too thin. It doesn't explain parameter semantics, file format expectations, output behavior, or error conditions. An agent would struggle to know what values to pass for 'blur' and 'erosion' and what the tool returns.

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 mentions 'erosion and Gaussian blur' which maps to the 'erosion' and 'blur' parameters, but it doesn't explain the meaning of 'input' and 'output' beyond their names, nor the units/ranges of erosion and blur (e.g., kernel size, sigma). The description adds minimal value over the raw schema.

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

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

The description states a specific verb ('refine') and resource ('PNG mask') with the operations 'erosion and Gaussian blur'. It distinguishes itself from sibling SAM2 tools (segment, track, inpaint) by focusing on mask post-processing. However, it doesn't explicitly name a sibling alternative or contrast with other mask tools like sam2_propagate_mask.

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: it is for refining an existing PNG mask, not for creating or propagating masks. It doesn't explicitly state when to use this tool vs alternatives like sam2_propagate_mask or sam2_segment_image. The context of 'needs only OpenCV and NumPy' hints at a lightweight post-processing step, but no explicit when/when-not guidance is given.

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

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

With no annotations, the description carries the behavioral burden and does disclose two useful traits: 'Output is muted' and 'perspective is approximate.' However, it does not mention side effects, file requirements, whether the operation is destructive, or what the tool returns, leaving meaningful behavioral gaps.

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

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

The description is a single terse sentence with no filler: it front-loads purpose, then technique, then output quality. It is appropriately sized for a compact definition, though its brevity crosses into under-specification.

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

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

This is a complex tool with seven parameters, no output schema, no annotations, and no schema descriptions, yet the description provides only a high-level algorithm and a quality caveat. It is not complete enough for an agent to determine how to populate the required parameters or what to expect as a result.

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 for all seven parameters, but it explains none of them. The phrase 'by mask plus a homography' hints at the algorithm but does not map to specific fields like points, labels, replacement, blur, or erosion, nor does it clarify their formats or relationships.

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

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

The description identifies a specific operation—screen replacement using a mask and homography onto an oriented rectangle—and the technique distinguishes it from the many sam2_* siblings focused on segmentation, tracking, and inpainting. It is not a tautology and gives a clear sense of what the tool does, though some jargon like 'oriented rectangle' could be more concrete.

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

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

No guidance is given about when to choose this tool over alternatives such as sam2_refine_mask, sam2_video_inpaint, or sam2_propagate_mask. The description states no use cases, prerequisites, or exclusions, so an agent must infer appropriateness from the name and context.

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

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

No annotations are provided, so the description alone must disclose behavior. It mentions the output format (PNG mask) and the underlying method (video predictor), but does not state whether the operation is destructive, what files are created or modified, or any side effects. Critical behavioral context 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 a single short sentence, which is concise but severely under-specified. It front-loads the purpose but omits almost all details needed for correct invocation. Conciseness without substance fails the requirement of being appropriately sized for the tool's complexity.

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

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

Given six parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain how to provide input, what points and labels mean, how output is handled, or any constraints. An agent has almost no chance of using this tool correctly based solely on the description.

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 provides no information about any of the six parameters (blur, input, labels, output, points, erosion). The agent cannot infer the meaning or format of these fields from the tool description, relying solely on the schema's bare names and 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 states the tool's purpose: it produces a PNG mask for a single image using SAM2 via the video predictor. This indicates the action and resource, and hints at a distinction from video-based siblings. However, it does not explain the role of points, labels, or other parameters, leaving the exact operation vague.

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 a single image (as opposed to video), which weakly differentiates it from sam2_segment_video. There is no explicit guidance on when to choose this tool over other SAM2 siblings like sam2_object_track or sam2_refine_mask, nor any conditions or prerequisites.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only reveals that the result is a series of PNG masks per video frame. It does not disclose side effects such as writing output files, overwriting existing files, required model/downloads, processing time, or whether it consumes all frames or a subset.

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 shortched, which could be considered concise, but it is under-specified rather than efficient. One fragment is not enough to support a 6-parameter tool and provides no operational structure beyond a vague output statement.

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, six parameters, zero schema coverage, no annotations, and no output schema, the description is far from complete. An agent lacks crucial context about input video paths, coordinate conventions for points, label semantics, blur/erosion effects, and the format/location of produced masks.

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 none of the six parameters are explained in the description. The description adds no meaning to input, output, points, labels, blur, or erosion, leaving the agent to guess at semantics and valid 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 fragment 'SAM2: a series of PNG masks, one per video frame' conveys the output format and video scope, so it is not a tautology, but it never states the operation with a verb such as 'segments' or 'generates'. It partially distinguishes from image segmentation by mentioning video frames, but it does not clearly define what inputs are consumed or what processing occurs.

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

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

The description provides no guidance on when to use this tool instead of closely related siblings such as sam2_segment_image, sam2_object_track, or sam2_propagate_mask. There is no mention of the intended use case, prerequisites, or exclusions.

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

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

With no annotations, the description carries the full burden and does disclose several behavioral traits: the result is non-generative, lacks temporal consistency, and is a silent video. It does not disclose side effects such as whether the output file is overwritten, how input audio is handled beyond silence, or whether any data is destroyed.

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

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

The description is very short and front-loads the algorithm and key caveats with no filler; every phrase contributes information. The telegraphic fragments, especially 'Silent video,' are somewhat terse and ambiguous, but the structure is efficient and not redundant.

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

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

The tool has six parameters and no annotations or output schema, yet the description provides almost no parameter documentation, input/output conventions, or side-effect information. The few caveats are useful, but the definition is not sufficient for an agent to reliably construct a complete call without external domain knowledge.

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 never names any of the six parameters. The mention of SAM2 indirectly hints that 'points' and 'labels' may be segmentation prompts, and OpenCV Telea hints at the inpainting approach, but blur, erosion, input/output path semantics, and label meaning are left unexplained.

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

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

The description identifies the core operation as 'spatial erasure' and names the composing methods (SAM2 + OpenCV Telea), which signals an object-removal/inpainting tool. It also distinguishes itself from generative alternatives by stating 'No generative model' and 'no guaranteed temporal consistency.' However, it never explicitly says it takes video plus point prompts and produces an inpainted video file.

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 stated limitations implicitly tell an agent when this tool is appropriate: use it for simple spatial erasure when generative content, temporal coherence, or retained audio are not required. It does not explicitly name sibling alternatives or provide concrete when-to-use/when-not-to-use conditions.

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

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

With no annotations, the description carries the disclosure burden. It usefully reveals the fallback behavior when web-dist is missing (build or use the Docker image). However, it does not disclose whether the start call blocks, starts a background server, or what side effects or prerequisites exist beyond web-dist.

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 concise sentences with no filler. The main action is front-loaded and the conditional fallback is stated in a single additional sentence, making the description easy to parse quickly.

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

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

The tool is simple, with one optional parameter and no output schema, so the description covers the core action and a key prerequisite. Still, it omits useful context such as how to stop the editor, whether the process stays alive, or what a successful start returns.

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 should compensate for parameter meaning. It does not mention the port parameter at all, though the schema itself provides type, default, and range. The description adds no semantic value beyond the schema's minimal 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 states a specific verb (Start), a resource (local editor), and a location (127.0.0.1). It clearly identifies the tool's purpose and differentiates it from media, rendering, and captioning siblings without needing to open the schema.

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

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

The intended use is implied: call this when you need the local editor running. It also gives conditional guidance about web-dist and Docker, but it does not explicitly state when not to use it or mention the companion ui_stop tool for stopping the editor.

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 and no output schema, so the description carries full burden. It clearly states the action but does not disclose side effects like whether active HTTP requests are terminated or whether the stop is idempotent. For a simple stop command this is adequate but not rich.

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

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

A single short sentence, front-loaded with the verb and resource, with zero wasted words. It earns its place perfectly.

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

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

For a tool with no parameters and no output schema, the description tells an agent what it does. The only gap is not explaining how this interacts with the editor's overall state (e.g., that ui_start can reverse it), but nothing essential to invoking it is missing.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%. The baseline for 0 params is 4; no additional parameter documentation is needed.

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

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

The description uses the specific verb 'stop' and names the resource ('the local editor's HTTP server'), making the action unambiguous. It naturally differentiates from siblings like ui_start and health_check, which are the start and status counterparts.

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

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

No guidance is given about when to stop the server or how this relates to alternatives. It does not mention that ui_start can restart it, nor any prerequisites such as the server already being running.

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