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

With no annotations at all, the description carries the full burden and does disclose two real behaviors: append-by-default with optional index insertion, and a 5-second default duration for images. It stays silent on mutation side effects, what happens with out-of-range src_out, how volume defaults are applied, and whether the operation is undoable.

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 compact sentences, front-loaded with the core action and range semantics, with the placement default and image duration appended as useful qualifiers. Nothing is wasted or padded.

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 six-parameter mutation tool with no annotations and no output schema, the description covers the non-obvious behaviors (append vs. insert, default image duration) that an agent could not infer. The remaining gap is the unmentioned volume parameter and asset-existence prerequisite.

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

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

Schema description coverage is 0%, so the description must compensate; it explains src_in, src_out, and index semantics well. However, volume, project, and asset_id are never mentioned, and the relationship between src_in/src_out and the resulting clip length is only hinted at via the image default.

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

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

States a specific verb and resource: places a clip from an asset onto the main track, with explicit src_in/src_out range semantics. This clearly separates it from sibling mutations like add_text, add_music, or move_clip, though it never names an alternative outright.

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

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

Usage is implied by the verb and the 'appends unless `index` is given' clause, which tells the agent how placement behaves. There is no explicit guidance on when to prefer this over add_music/add_text/import_media, nor a stated prerequisite that the asset must already exist.

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 supplied, so the description carries the full burden. It adds real value by explaining what duck=True actually does (automatic level reduction under speech), which the bare boolean does not convey. However, it says nothing about mutability side effects, whether the new layer coexists with existing music, permission requirements, or what the call returns, leaving meaningful behavioral gaps for a mutation tool.

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

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

Two tight sentences with the core operation front-loaded and the duck behavior second. Nothing is redundant or padded.

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?

Nine parameters, no annotations, no output schema, and no schema descriptions mean the description should do much more. It explains only start and duck, leaving the source offset, duration-null semantics, volume scaling, and fade defaults undocumented, which is not enough for an agent to call this correctly without guessing.

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% across nine parameters, so the description must compensate. It clarifies two critical parameters: `start` as a timeline position (not a source offset) and `duck` as automatic ducking under main-track audio. That distinction between timeline time and source-in is genuinely useful. But `src_in`, `duration` (including the null default), `volume`, and the fade parameters remain entirely unexplained in both schema and 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 gives a specific verb and resource: lay background audio under the main track, starting at a timeline time. That clearly separates it from siblings like add_clip or remove_music, though it doesn't name those alternatives explicitly.

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

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

The purpose implies the usage scenario (adding a music bed under existing audio), and the duck note hints at the speech-overlap case. There is still no explicit when-to-use or when-not guidance, such as pointing to remove_music for removal or import_media for getting the asset in the first place.

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 supplied, so the description carries the full behavioral burden. It says "pin" but never discloses whether the note persists across sessions, whether the call fails on an out-of-range time, what identifier is returned for later resolve_note calls, or that author defaults to "agent" — all material 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?

One sentence, front-loaded with the action and the target, with zero filler. It is efficient rather than padded, though the brevity leaves the gaps noted elsewhere unaddressed.

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 four-parameter write tool with no annotations, no output schema, and no schema descriptions, this single sentence leaves too much unspecified. The agent cannot determine time units, the meaning of project/author, or what to do after adding a note (resolve_note exists as a sibling).

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% across four parameters, so the description must compensate and largely doesn't. It clarifies that "time" means a position on the timeline but not the unit (seconds vs. frames), and it says nothing about what "project" expects or that "author" defaults to the agent.

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 specific verb-plus-resource ("Pin a review note") and a target ("a timeline time"), so the agent knows exactly what object is created and where it attaches. It implicitly separates itself from siblings like list_notes and resolve_note, though it never names 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 parenthetical "e.g. a question for the human" gives one concrete motivating scenario, which implies when to reach for this tool. There is no explicit when-not guidance, no mention of the resolve_note follow-up workflow, and no stated prerequisites such as an existing project or valid timeline range.

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

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

With no annotations, the description carries the full behavioral burden and discloses very little: no indication of whether the call returns an overlay id needed for later update_text/remove_text, no statement about overlapping text or default styling behavior. It does contribute the useful fact that font_size is normalized to a 1080p canvas and that \n creates line breaks, which is real added context.

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

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

Two front-loaded sentences with no padding, and the parameter hints are appended where an agent will look. It is efficient, though the terseness contributes to the coverage gaps noted above.

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

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

For an 8-parameter mutation tool with no annotations, no output schema, and no per-parameter schema descriptions, the description is far from complete. An agent still cannot tell the units of start/end, what the return value is, or how this relates to update_text/remove_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% across 8 parameters, so the description must compensate and largely does not. It clarifies font_size scaling and newline handling in text, but leaves project, start, end, color, box, and the position enum (top/center/bottom/lower-third) unexplained, including whether start/end are seconds or frames.

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

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

States a specific verb and resource ('Add a text overlay') plus the scope ('at timeline times'), so an agent knows exactly what the tool produces. It does not distinguish itself from siblings like update_text or remove_text, so it stops short of a 5.

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

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

Nothing says when to use this versus update_text (modifying existing overlay) or remove_text. The phrase 'at timeline times' hints at placing new timed overlays, but there is no explicit when/when-not guidance and no mention of prerequisites such as the project already existing.

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 supplied, so the description carries the full behavioral burden. It discloses the return content (LUFS, true peak, curve), which is genuinely useful with no output schema, but says nothing about whether this is a pure read, whether it decodes arbitrarily long media, whether asset_id and render_path are mutually exclusive, or what happens if neither is given.

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

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

Two sentences, front-loaded with the returned measurements, followed by one actionable calibration fact. No filler and nothing repeated from the schema or title.

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 four-parameter tool with no annotations and no output schema, the description covers the outputs adequately but leaves the input contract and the read-only/performance profile unaddressed. An agent could call it, but would be guessing about window units and asset_id/render_path precedence.

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 parameters carry only titles. The phrase 'an asset or a rendered file' hints at asset_id vs render_path, but gives no conflict resolution, and 'per-window loudness curve' only vaguely gestures at the window parameter without stating units or meaning. project is entirely 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?

Names a specific measurement resource (integrated loudness in LUFS, true peak, per-window curve) applied to either an asset or a rendered file. That is a precise verb-less but unambiguous analysis purpose, and it is separable from audio_waveform and detect_silence by what it returns. It stops short of explicitly framing itself as a read-only measurement pass, so not a 5.

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

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

The YouTube -14 LUFS sentence implies a use case (checking whether a master will be normalised down), which is real guidance, but usage is implied rather than stated. There is no explicit when-to-use versus audio_waveform or detect_silence, and no exclusions or prerequisites.

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

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

There are no annotations, so the description bears the full disclosure burden, and it largely stops at the output type ('waveform image'). It says nothing about whether this is a read-only render, what resolution or duration of audio is covered by default, whether asset_id and render_path are mutually exclusive, or what happens if neither is supplied.

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 or redundancy. It is efficient, though the brevity comes at the cost of the missing behavioral and parameter detail scored above.

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, no output schema, and no parameter descriptions, the definition is too thin. An agent cannot tell from the text alone how to choose between the two source parameters or what the default time window is.

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% across five parameters, so the description must compensate and mostly does not. The phrase 'an asset's or a rendered file's audio' only indirectly hints that asset_id and render_path are two alternative sources; start and end, which clearly bound the analyzed time range, get no mention at all.

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

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

The description names a concrete output (a waveform image) and the resource it derives from (an asset's or a rendered file's audio), which is more specific than the bare name. It also gestures at the diagnostic purpose (speech, pauses, peaks), helping separate it from audio_loudness and detect_silence, though it does not name those siblings explicitly.

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

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

'To spot speech, pauses and peaks' implies the analysis scenario in which this tool fits, so usage is inferable. However, with siblings like detect_silence, audio_loudness, and transcribe in the same space, no when-to-use/when-not-to-use guidance or alternative routing 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 full burden and does disclose two useful behaviors: frames reflect the EDITED timeline (not the source media) and overlays/captions are composited in. It omits the cost/latency of rendering, whether the project must be saved first, and whether the operation is read-only.

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

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

Two sentences, zero filler, with the purpose and the output form front-loaded before the usage directive. Every clause carries information the agent needs.

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 moderate-complexity render tool with no annotations and no output schema, the description adequately explains what comes back (a single labelled grid) and the edited-timeline semantics. It remains incomplete on parameter meaning and on the practical cost/behavior of rendering.

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% across four parameters, and the description clarifies only one of them implicitly: frames are sampled at 'timeline times' rather than source times. Nothing is said about width, columns, or the project identifier, including how width/columns relate to the 'labelled grid' layout.

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?

"Render frames of the EDITED timeline at the given timeline times ... return them as one labelled grid" states a specific verb (render) and resource (frames), plus the output shape. It does not explicitly distinguish itself from the siblings render_preview or timeline_contact_sheet, so the agent must infer that difference.

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

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

"Use after every edit to verify it" gives a crisp triggering condition that fits into an edit loop. It stops short of naming alternatives or exclusions (e.g., when to use render_preview or timeline_contact_sheet instead).

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 supplied, the description carries the full behavioral burden and does not meet it. It does not say what the tool returns (project ID, handle), whether the new project becomes the active one for subsequent add_clip/import_media calls, whether duplicate names are allowed, whether the operation is reversible, or whether anything is persisted. Only the canvas-fitting behavior is disclosed.

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

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

Two short sentences, front-loaded with the action and followed by the only non-obvious semantics. No filler, no restatement of the tool name beyond the necessary verb.

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 creation tool with no annotations and no output schema, the description covers canvas configuration but leaves the caller unsure about the result and side effects of creating a project. Adequate to invoke, but not complete enough to invoke confidently in a multi-step editing 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, and it does add genuine meaning for `fit` (contain = letterbox, cover = crop) and ties width/height/fps to the canvas concept. However, `name` is unexplained, and no units, valid ranges, or constraints are given for width/height/fps, leaving half the meaning to be inferred.

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

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

The description opens with a specific verb and resource ("Create a new project") and immediately clarifies what the canvas parameters do. It is clearly distinct from list_projects or update_settings by verb alone, but it never explicitly names a sibling or states the boundary (e.g. create vs. update_settings).

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 versus alternatives such as update_settings or list_projects, and no prerequisites are stated (e.g. whether one must import media first, or whether a project must already exist for other tools). The only usage-adjacent content is the explanation of the `fit` enum, which is parameter semantics rather than when-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, the description carries the full behavioral burden, and it does disclose one genuinely useful trait: downstream content ripples left, so the agent knows the timeline is reflowed rather than left with a gap. It omits whether the deletion is undoable, what happens to linked audio/text, and what is returned.

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

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

A single compact sentence that front-loads the action and appends the key side effect. Nothing is wasted, though the brevity is close to the edge of under-specification for a destructive mutation.

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 destructive timeline mutation with no annotations, no output schema, and zero parameter documentation, so the description is the only source of truth. It covers the ripple consequence but leaves undoability, dependency handling (linked media, captions), and identifier sourcing entirely unaddressed.

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

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

Schema description coverage is 0% for both required parameters, so the description must compensate and does not. Neither clip_id nor project is explained — the agent gets no hint about identifier format, where clip ids come from, or how the project scopes the lookup.

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?

"Remove a clip" gives a specific verb and resource, clearly distinguishing it from add_clip, trim_clip, and split_clip by intent. However, it never contrasts with the closely named delete_range sibling, leaving the timeline-scope distinction to be inferred from the name alone.

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

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

There is no explicit when-to-use or when-not-to-use guidance. An agent must infer from the name that this removes a whole clip rather than a time range (delete_range) or a partial trim (trim_clip), and no prerequisites such as project context or clip lookup are stated.

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

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

With no annotations, the description carries the full load and does disclose the non-obvious ripple side effect: overlays and notes after the range shift left, and the cut spans clip boundaries. It omits reversibility (undo availability) and whether the affected tracks include audio and video alike.

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 the operation and its consequence front-loaded first and the range semantics second; no filler or repetition.

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

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

For a destructive, annotation-free tool with three undocumented parameters and no output schema, the description covers the ripple behavior well but leaves units, the project argument, and undo/irreversibility unresolved. Adequate, but an agent could still call it with wrong units or wrong assumptions about undo.

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. It clarifies that start/end form a timeline range (square brackets suggesting inclusive bounds) and that the range may cross clips, but time units (seconds vs. frames) are unstated and the "project" parameter is never mentioned at all.

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?

"Ripple-delete [start, end] of the timeline" names a specific verb and a specific resource region, and the parenthetical examples (a pause, a fumbled sentence) make the intent concrete. It implicitly differs from delete_clip via "range" and "works across clip boundaries," though no sibling is named explicitly.

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

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

The examples imply the use case (removing dead air or mistakes), but the description never states when to choose this over delete_clip, split_clip, or remove_silences, nor any precondition. Usage is inferable rather than instructed.

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

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

With no annotations, the description carries the full burden. It does add useful behavior beyond the name: the results are timestamps in source time (not timeline time) and the threshold direction is explained, but it never states whether the call is read-only or mutates project state, whether it is expensive/long-running, or whether results are cached between calls.

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, and the most decision-relevant fact (threshold sensitivity direction) is placed early. It is efficient rather than bloated, though the terseness contributes to the missing operational 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 three-parameter analysis tool with no annotations and no output schema, the description should clarify identifier expectations, whether the operation is read-only, and the shape of the returned timestamps (list? per-shot objects?). It covers the return concept loosely but leaves most operational questions unanswered.

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, yet it only explains one of three parameters (threshold, including its direction of effect and default 0.3). The required 'project' and 'asset_id' parameters get no explanation of expected identifier format or scope.

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 specific resource and result: shot-change timestamps in a video asset, which pairs with the detect_silence/detect_* siblings and is distinguishable from generic inspection tools. The verb itself is left implicit (it describes the output rather than saying 'detects scene changes'), but an agent can still infer the operation reliably.

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

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

Usage is implied only: the presence of a threshold hints at tuning sensitivity, but there is no statement of when to call this versus inspect_media or check_frames, no prerequisites (does the asset need to be imported/analyzed first?), and no when-not guidance.

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

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

With no annotations, the description carries the full behavioral burden; it does disclose that results are silent ranges with source-time timestamps, which is useful non-obvious context. It does not state that the operation is read-only, whether it modifies or caches anything, permission requirements, or how expensive it is.

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

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

The description is a single short fragment with zero wasted wording and the output concept is front-loaded. It is terse and under-specified, but from a pure conciseness/structure standpoint 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 four-parameter analysis tool with no annotations, no output schema, and 0% schema description coverage, the definition is too thin. It gives the return concept but omits parameter meanings, scoping details, and behavioral constraints an agent needs to call it confidently.

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

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

Schema description coverage is 0% and the description does not explain any of the four parameters. It never clarifies project/asset scoping, the noise_db threshold, or the units/meaning of min_duration, so the agent gets no semantic help beyond the bare titles and defaults.

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

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

The description names the resource (an asset's audio) and the result (silent [start, end] ranges in source time), so it is clear this detects silence rather than loudness or waveform. It does not explicitly distinguish itself from siblings such as remove_silences or audio_loudness, so it stops short of a 5.

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

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

There is no when-to-use guidance, no alternatives named, and no prerequisites or exclusions. An agent can infer from the name that it is for finding silent ranges, but the description provides no routing help among the many audio/timeline 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?

No annotations are supplied, so the description carries the full burden; it does disclose real behavior — presets drive resolution and loudness to -14 LUFS, and a sidecar .srt is written when captions are enabled. It omits whether the export overwrites existing files, where output lands, whether the call blocks or returns a job handle, and any permission or duration constraints.

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

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

Three short sentences, front-loaded with the operation name, no filler. The GPU-encoder line repeats enum knowledge from the schema but adds the 'if the machine has one' condition, so it still earns its place.

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

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

With five parameters, zero schema coverage, no annotations, and no output schema, the definition leaves most of the agent's decision surface unexplained: output destination, filename default behavior, quality-vs-preset interaction, and return semantics. What is present is accurate but insufficient for a terminal, file-writing operation.

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

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

Schema description coverage is 0%, so the description must compensate; it partially does by explaining that presets control resolution and loudness with the concrete -14 LUFS target for youtube/shorts/square, and by recommending GPU encoders. It says nothing about `quality`, `filename` (including the null default), or `project` beyond it being required.

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 'Final render', which names the operation and implicitly distinguishes it from the sibling render_preview by scope. It doesn't name render_preview explicitly, but the verb+resource is specific enough for an agent to select it over preview rendering.

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

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

Usage is only implied by the word 'final' in contrast to render_preview; there is no explicit when-to-use/when-not statement. The GPU-encoder sentence is parameter-selection advice rather than routing guidance between tools.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses very little. It does not state that this is a read-only operation, whether it needs a specific project handle or permission, how large the response can be, or whether omitted things (closed notes, unused assets) are excluded.

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

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

It is short and every listed element (clips, overlays, music, notes, assets) conveys part of the payload, so nothing is padding. But it is written as a fragment rather than a front-loaded sentence, which costs clarity without saving many tokens.

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

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

With no output schema, no annotations, and an undocumented required parameter, the description should do more of the work. Ambiguous terms like 'open notes' and 'assets' are left unexplained, and the agent cannot tell the expected response size or structure before calling.

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% for the single required 'project' parameter, so the description must compensate and it does not mention the parameter at all. It never says whether 'project' is a name, ID, or path, nor what happens if the project is unknown.

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 being returned — the complete edit with clips (timeline and source times), overlays, music, open notes, and assets — which broadly signals a full-timeline read. However, it is a noun-phrase fragment with no verb, and nothing distinguishes it from siblings like timeline_contact_sheet or check_frames beyond an implicit sense that this one is 'full'.

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

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

There is no when-to-use guidance at all: no statement of what task this read serves, no exclusions, and no pointer to alternatives such as timeline_contact_sheet for a lightweight overview. An agent must infer that this is the heavy, complete read from the words 'the full edit'.

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 burden. It does disclose the non-obvious semantic that the no-asset_id mode returns 'only words that survive the edit', which is valuable. But it is silent on error conditions, whether an un-transcribed project returns empty, and any cost/latency characteristics of reading a full transcript.

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

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

Three short sentences, front-loaded with the action and immediately followed by the mode distinction and the filter behavior. No filler. Slightly telegraphic phrasing ('With asset_id: source time') but nothing wasted.

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

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

An output schema exists, so return-value detail is not required, and the description covers the two mode branches and the filter that govern the result set. The remaining gap is the unexplained start/end windowing, which matters for a range-based read on a 5-parameter 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. It explains asset_id and query meaningfully (source vs edited timeline, substring filtering), but start and end — two numeric bounds with a default of 0 — get no explanation of units or inclusivity, leaving half the parameters undocumented.

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

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

States a specific verb and resource ('Read a transcript as timestamped lines') and goes further by describing two distinct output modes tied to asset_id. It is clearly distinguishable from siblings like transcribe or import_transcript, though it never names those alternatives explicitly.

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

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

Gives a clear conditional: supply asset_id for source-time readings, omit it for the edited timeline. That is genuine when-to-use guidance for the main branch point. It does not, however, say when to prefer this over transcribe/get_timeline or what to do if no transcript exists yet.

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 supplied, so the description bears the full behavioral burden. It discloses the ordering (oldest first), which is genuinely useful, but says nothing about read-only safety, per-project scoping behavior, what an entry contains, or what happens if the stack is empty.

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 with the ordering constraint front-loaded and no filler. It is efficient, though its brevity edges into under-specification rather than elegant concision.

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 (one param, no nesting, no output schema), yet with no annotations and an undocumented parameter the description leaves too much for the agent to infer. It should state that this is a read-only listing scoped by project and point to 'undo'/'redo' for the actual stack operations.

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 required parameter 'project' has 0% schema description coverage, and the description does not mention it at all. It is unclear whether 'project' is a name, ID, or path, or whether history is scoped per project.

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 resource ('undo/redo stack descriptions') and a scope ('oldest first'), so an agent can tell it returns history data rather than performing an action. However, it is a noun phrase with no verb (list/get/describe), and the distinction from the sibling tools 'undo' and 'redo' is only inferable, never stated.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to the obvious alternatives 'undo' and 'redo'. An agent must guess that this is the read-only inspection counterpart to those mutation tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that files are added to the asset library and must be absolute paths on the server machine, but it omits side effects, duplicate or overwrite behavior, permissions, supported formats, error conditions, and what the call 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 two sentences, front-loaded with the core action, and contains no filler. The path constraint follows naturally as an operational note.

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 three-parameter mutation tool with no annotations, no schema descriptions, and no output schema, this is too sparse. It is missing parameter meanings, side-effect details, and return/error expectations that an agent would need before invoking it confidently.

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

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

Schema description coverage is 0%, so the description must compensate for all three parameters. It explains only that paths must be absolute; project and labels are left unexplained, and the role of labels in the asset library is not clarified.

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

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

The description states a specific verb and resource: adding video, audio, and images to the project's asset library. That is clear enough to distinguish importing assets from timeline-oriented siblings like add_clip or add_music, but it does not explicitly name any sibling or boundary.

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 asset-library framing implies when to use this tool, and the absolute-path requirement gives a practical precondition. However, it does not say when to use import_media versus add_clip, add_music, inspect_media, or import_transcript, nor does it mention when not to use it.

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

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

With no annotations, the description carries full burden; it does add one genuinely valuable behavioral constraint — timecodes must be in source time, not timeline time. It omits the important mutation semantics: whether an existing transcript is overwritten, whether the call fails on malformed subtitles, and permission requirements.

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

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

One sentence, front-loaded with the verb and resource, with the format and time-base constraints packed inline. Nothing is wasted and nothing needs reordering.

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

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

There is no output schema and no annotations, so the description is the only behavioral source, and it covers format plus time base but not the outcome (what is returned, replace vs. append, error behavior). Adequate to attempt a call, insufficient to predict its 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 coverage is 0% and all three titles are bare camel/snake labels, but the description compensates for the riskiest parameter by fixing `subtitle_path` to .srt/.vtt files in source time. `project` and `asset_id` receive no added meaning beyond their names (e.g., ID format or how the target asset is resolved).

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

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

Specific verb ("Attach") plus resource ("transcript") and accepted file types, which separates it from the sibling `transcribe` (generation) and `get_transcript` (retrieval). It stops short of explicitly naming those siblings, so the differentiation is inferable rather than stated.

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?

"Existing ... file" implies the pre-condition that the caller already has a subtitle file, which implicitly routes generation requests to `transcribe`. There is no explicit when-to-use/when-not-to-use statement, no mention of whether an asset may already have a transcript that would be replaced, and no prerequisites.

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

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

No annotations are supplied, so the description carries the full burden. It does usefully describe the shape of the result (evenly spaced frames, each labelled with a source timestamp), which is real behavioral disclosure, but it never states that the call is read-only/non-destructive, whether frame extraction is expensive, or what form the sheet is returned in.

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 tight sentences, front-loaded with what the tool produces before the usage hint. Backticked parameter names and bracket notation for the range make it easy to scan; nothing is 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?

With no annotations, no output schema, and 0% schema coverage across six parameters, the description should do more: it leaves the return medium ambiguous and omits `columns`. It covers the core concept adequately but not the operational details an agent needs.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `count` (evenly spaced), and the `start`/`end` interval, but leaves `columns`, `project`, and `asset_id` entirely undocumented, and never clarifies that a null `end` means running to the end of the asset. Three of six parameters gain no 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 names a specific verb+resource pair: it produces a contact sheet of `count` evenly spaced frames from a source asset's [start, end] range. The phrase 'of a source asset' implicitly distinguishes it from the timeline-wide `timeline_contact_sheet` sibling, but it never names that sibling or `check_frames` explicitly.

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

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

'Use it to see what is in a clip' gives a general use case but no when-not guidance and no named alternatives, even though `check_frames` and `timeline_contact_sheet` are plausible competing choices. The guidance is implied rather than 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?

No annotations are provided, so the description carries the full disclosure burden. It does volunteer one behavioral fact — results come back in timeline order — and the verb 'Review' plus the tool name signal a read-only operation, but it never states whether resolved notes are excluded by default, whether results are scoped to one project, or whether there is any pagination.

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 the ordering constraint placed up front and an inline example that makes 'notes' concrete. Nothing is wasted or padded.

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 two-parameter read tool with no output schema, the description covers what a note is and how results are ordered, which is a reasonable minimum. It falls short on the resolved/active distinction and on what a returned note looks like, both of which an agent needs to use the results correctly.

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

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

Schema description coverage is 0%, so the description must explain both parameters and does not. 'project' and 'include_resolved' are only inferable from their names; the description says nothing about whether project is an ID or a name, or that resolved notes are omitted unless include_resolved is set.

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

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

The description names the resource (notes) and adds a clarifying gloss — 'human feedback such as "cut this pause"' — plus a return ordering ('in timeline order'). That is more than the title/name alone conveys, though it never explicitly contrasts itself with the sibling mutations add_note and resolve_note.

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?

Reviewing existing human feedback implies the read-side use case against add_note/resolve_note, but the guidance is only implied. There is no explicit statement of when to prefer this over resolve_note, or when a caller should set include_resolved.

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 supplied, so the description carries the full disclosure burden. The word "existing" weakly implies a non-mutating read, but nothing is said about permissions, result ordering, pagination, or whether the response contains names, IDs, or full project objects.

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 or redundancy. It is efficient, though its brevity edges toward under-specification rather than crisp precision.

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

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

For a zero-argument list tool with no output schema, the description covers the basic purpose but omits what the returned project records contain and whether the list can be large. An agent knows what the tool does but not what it gets back.

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 takes zero parameters, so there is no parameter semantics for the description to explain. The baseline of 4 applies; nothing in the schema is left 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?

Description gives a specific verb ("List") and resource ("Reelwright projects"), which is enough to distinguish it from the mutation sibling create_project. It stops short of naming that sibling or stating scope (all projects vs. filtered), so it is clear but not fully differentiated.

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

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

Usage is only implied: an agent can infer this is the read-side counterpart to create_project when it needs existing project identities. There is no explicit when-to-use statement, no prerequisites, and no mention of 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?

No annotations are provided, so the description carries the full disclosure burden and largely doesn't. It reveals that the move is confined to the main track and that indexing is zero-based, but says nothing about whether the move is reversible, what happens to clips shifted by the reorder, whether an out-of-range index errors or clamps, or what the call 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?

A single front-loaded sentence with no filler; the parenthetical '0 = first' is the one piece of detail that earns its place. It is arguably over-terse for a mutation tool, but nothing is wasted.

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

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

For a three-parameter mutation tool with no annotations, no output schema, and zero schema coverage, the description is too thin. It should at minimum clarify the reorder semantics (shift vs. swap), failure behavior for invalid indices, and whether the operation is undoable via the sibling undo/history 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. It usefully pins down the only genuinely ambiguous parameter — index is zero-based with 0 meaning first — but leaves project and clip_id entirely unexplained, relying on the agent to infer their meaning from the names.

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 (Move) and resource (clip) plus the scope constraint 'main track', which distinguishes it from siblings like trim_clip, split_clip, and add_clip. It does not name an alternative explicitly, but the operation 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?

Usage is only implied by the verb — reorder an existing clip rather than insert or remove one. There is no explicit when-to-use statement, no mention of prerequisites (does the clip need to exist, must it already be on the main track?), and no comparison to overlapping siblings such as delete_clip plus 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?

No annotations are provided, so the description carries the full disclosure burden. It does not say what happens when there is nothing to redo (error vs. no-op), whether the redo stack survives a new edit, or whether the restore is scoped to the given project.

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 the action front-loaded and no filler. The brevity is appropriate in form, though it leaves content gaps rather than wasted words.

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

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

For an unannotated mutation-style tool with an undocumented required parameter and no output schema, the definition is too thin. An agent cannot tell how failures or no-op cases behave, or what 'project' should contain.

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 required parameter 'project' has 0% schema description coverage and the description never mentions it, so its meaning (project ID vs. name, and why redo is project-scoped) must be inferred. With only one param, a brief clause would have closed this gap.

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

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

States a specific verb and effect: 'Redo the last undone edit', which is clearly distinct from the sibling 'undo'. It does not explicitly name the sibling or note that it operates within a single project, 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?

Usage is only implied by the word 'redo' — reuse of a reverted edit. There is no guidance on when to prefer 'undo', 'history', or direct edit tools, and no statement of preconditions such as whether an undone edit must exist.

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 supplied, so the description carries the full behavioral burden. It says 'Delete' but never states whether the removal is permanent, whether undo can reverse it, what permissions are needed, or what happens to the surrounding timeline — all critical for a destructive mutation.

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 or redundancy. It is efficient, though the brevity borders on under-specification for a destructive operation.

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

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

For a destructive mutation with no annotations, no output schema, and two undocumented parameters, the description is far too thin. It omits reversibility, scope of effect, and parameter meaning, leaving the agent with almost nothing beyond the tool name.

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 neither required parameter (project, music_id) is explained in the description. The phrase 'music cue' only loosely hints at music_id, leaving the agent to guess the identifier's source and the project's role.

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 specific verb and resource ('Delete a music cue'), so an agent can tell this apart from add_music or set_clip_volume. It does not explicitly name the sibling it complements, but the purpose 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 guidance on when to use this versus alternatives such as add_music or the broader delete_clip/delete_range tools. No prerequisites, conditions, or exclusions are stated.

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

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

With no annotations provided, the description carries the full burden, and it does disclose the most important side effect: a ripple delete applied to every clip on the timeline, with padding preserved to avoid clipping speech. It does not say whether the edits are undoable or how it behaves when no silence is found, which are meaningful gaps for an unannotated 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?

Two sentences, front-loaded with the primary action and scope, followed by the safety hint. No filler, no restatement of the tool name, and every clause carries 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 5-parameter, unannotated, destructive timeline operation with no output schema, the description covers the core action and the ripple side effect well. It is still incomplete on the tuning parameters and on the return/undo behavior an agent needs before executing a batch edit.

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 genuine meaning for padding (seconds of audio kept either side of a cut) and dry_run (preview mode), but leaves noise_db and min_silence — the two parameters that actually control what counts as silence — with no units, thresholds, or directionality explained.

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

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

The description names a specific verb chain (detects silence, ripple-deletes) and an explicit scope: every clip's audio across the whole timeline. It is operationally distinct from the sibling detect_silence because it states the content is deleted and the timeline is rippled, not merely reported.

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 concrete workflow directive — run with dry_run=True to preview the cuts before committing — which is real when-to-use guidance. It stops short of naming alternatives (e.g. detect_silence for a read-only check) or stating when not to run it (e.g. clips with no audio track).

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

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

No annotations are provided, so the description carries the full burden. It does not say whether deletion is permanent, whether it can be undone, or whether an invalid overlay_id errors or no-ops—all material for a destructive operation.

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

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

A single short sentence with no wasted words, but also no useful content added. It is appropriately terse yet under-informative rather than efficiently 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?

Although the tool is simple (two required strings, no nesting, no output schema), a destructive operation with zero annotation coverage and zero parameter descriptions leaves the agent guessing about identifier formats and reversibility.

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 for either parameter. It does not explain what "project" identifies (name, slug, or ID) or what form an overlay_id takes or how to obtain one.

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

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

The description gives a specific verb plus resource ("Delete" + "text overlay"), which lets an agent distinguish it from add_text and update_text among the siblings. It does not explicitly name those siblings, but the operation 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 guidance on when to use this versus update_text or add_text, and no prerequisites such as where an overlay_id comes from. The agent must infer everything from the name and the two required parameters.

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

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

With no annotations, the description carries the full burden, and it does disclose the key traits: speed, output quality (low-res MP4), scope (full edit or a sub-range), and the return value (file path). It omits where the file is written, whether an existing preview is overwritten, and the cost/rendering implications for long timelines.

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, front-loaded with the action and output format, then the return value. No filler or redundant restatement.

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 rendering tool with no annotations, no output schema, and zero parameter documentation, the definition leaves important gaps: time units and range semantics, where the MP4 lands, and any cost or overwrite behavior. What is present is accurate but insufficient for confident invocation.

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

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

Schema coverage is 0%, so the description must define all three parameters, and it only gestures at two of them via '[start, end]' without units (seconds vs. frames), inclusivity, or behavior when omitted. The required 'project' parameter is never mentioned, and the relationship between start/end and the project timeline is unstated.

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+artifact: produces a fast, low-res MP4 of the edit (or of a [start, end] range) and returns a file path. The 'for review' framing distinguishes it from the heavier 'export' sibling, though it never names that sibling explicitly.

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

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

'for review' plus 'fast low-res' implies this is the quick-check path rather than final delivery, so an agent can infer when to prefer it over export. There is no explicit when-to-use/when-not statement, no mention of the check_frames or timeline_contact_sheet alternatives for cheaper visual inspection, and no 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 at all, the description carries the full behavioral burden and largely drops it: it does not say whether the change is reversible, whether an already-resolved note errors or is a no-op, whether other reviewers' notes are affected, or what the response contains. The word "Mark" hints at a mutation but no state, permission, or idempotency details are disclosed.

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

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

A single front-loaded sentence with zero filler. It is efficient, but the brevity is under-specification rather than tight writing given the missing behavioral and parameter 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 two-required-parameter mutation tool with no annotations, no output schema, and no schema descriptions, the definition supplies almost nothing beyond the name. An agent cannot predict failure modes, side effects, or return shape from this text 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% for both required parameters, so the description must compensate and does not — neither `project` (does it scope the lookup, or is it the target?) nor `note_id` (format, where obtained) is mentioned. The only implicit cue is that "note" in the description loosely corresponds to note_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?

States a concrete verb phrase ("mark as handled") against a specific resource ("review note"), which is distinguishable from siblings like add_note and list_notes without opening a schema. It stops short of explicitly contrasting itself with those siblings or naming the unresolved->resolved state transition.

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 call this versus add_note or list_notes, no statement of prerequisites (e.g. note must exist and be open), and no mention of the related undo tool. The agent must infer the workflow entirely.

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

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

Without annotations, the description must carry the full behavioral burden. It usefully discloses that captions are generated from asset transcripts, follow edits automatically, and that burn_in=False exports a sidecar .srt. It does not explain mutation effects, whether a transcript is required, or what happens when captions are disabled.

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

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

The description is short, front-loaded, and free of filler. Three sentences cover the core action, generation behavior, and burn-in distinction without unnecessary repetition.

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

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

For a six-parameter mutation tool with no annotations, no output schema, and zero schema description coverage, the description is incomplete. It covers the main purpose and burn_in behavior but leaves most styling and control parameters unexplained.

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 all six parameters. It only explains burn_in=False as producing a sidecar .srt instead of drawing captions; enabled, project, font_size, max_chars, and max_duration receive no added meaning.

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

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

The description clearly states the specific action and resource: turning captions on or off. It is distinct from text tools like add_text, though it does not explicitly name the sibling alternatives it differs from.

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

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

The phrase 'Turn captions on/off' implies when the tool is used, and the note about generated transcripts provides context. However, it gives no explicit when-to-use guidance versus related tools such as add_text, and no prerequisites or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the gain semantics (1.0 = unchanged, 0 = mute), which is important for correct invocation. However, it omits other behavioral details such as acceptable range beyond the examples, whether changes are reversible, required permissions, and 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, front-loaded sentence with no unnecessary wording. The most important semantic detail, the gain scale, is included immediately.

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 three-parameter setter with no output schema and no annotations, the description covers the core operation and key volume semantics. However, given zero schema description coverage, it should do more to explain the project and clip_id parameters and valid volume bounds.

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 three parameters. It partially explains the volume parameter by giving the scale semantics, but says nothing about clip_id or project. With all parameters undocumented in the schema, this leaves significant gaps.

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

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

The description uses a specific verb and resource: 'Set a clip's audio gain.' This clearly identifies the operation and distinguishes it from general audio tools like audio_loudness. However, it does not explicitly differentiate itself from nearby editing siblings such as trim_clip or split_clip beyond the resource name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention related siblings like audio_loudness or audio_waveform, nor does it state any preconditions or exclusions for setting clip volume.

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 supplied, so the description carries the full burden. It says nothing about whether the cut is reversible, whether it requires the clip to be selected or locked, which track is targeted, or what happens if no clip exists at that time.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness contributes to the missing behavioral and parameter detail rather than compensating for it.

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 edit operation the core action is conveyed, but with no annotations, no output schema, and zero schema coverage the definition leaves an agent without enough information about targeting and side effects.

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

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

Schema coverage is 0%, and the description only partially compensates: 'timeline time' hints at the semantics of the 'time' parameter, but the required 'project' parameter is never mentioned, nor are time units or format.

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

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

The description names a specific verb ('Split') and resource ('clip') and adds a locating condition ('under a timeline time'). It is distinguishable from trim_clip and delete_range, though it never names those siblings explicitly.

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

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

There is no guidance on when to split rather than trim or move a clip, no prerequisites, and no statement about which clip is selected when several clips overlap the given time.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It states that the result is one image and that frames are evenly spaced across the edited timeline or a range, but it does not clarify whether the operation is read-only, whether it modifies the project, where the image is written, or what format is returned.

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 wording. It is front-loaded with the core output concept, though it lacks an explicit action verb and reads more like an output summary than a complete instruction.

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 parameters at 0% schema description coverage, the description is too sparse. It omits important invocation context such as units, defaults, output handling, and whether the operation is safe or destructive.

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 carry parameter meaning. It conceptually maps the four parameters by implying a project timeline, a range via start/end, and a count through evenly spaced frames, but it does not specify units, defaults, or the exact meaning of each named 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 clearly identifies the output as a contact sheet of evenly spaced frames from the edited timeline or a selected range. It is distinguishable from generic timeline tools, but it does not explicitly contrast itself with siblings such as get_timeline or check_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 when-to-use guidance, no prerequisites, and no named alternatives among the many sibling timeline/frame tools. The optional range is mentioned but not framed as a usage rule or decision point.

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

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

With no annotations, the description carries the full burden; it does disclose two real behaviors: an optional dependency install is required, and results are cached rather than returned for direct consumption. It omits whether this is long-running or expensive, whether it mutates project state, and how the model choice affects speed/accuracy.

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, front-loaded with the action and its output, then the prerequisite and the read-back path. Nothing is wasted or buried.

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-style tool with no output schema and zero-documented parameters, the definition covers the call/read workflow and the install requirement, which is the most important framing. It still leaves open the parameter tradeoffs (model, language) and whether the call blocks or returns a status, so an agent can call it but not call it well.

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 and largely does not. It implies asset_id via 'an asset' but says nothing about the model (default 'base'), language (nullable, presumably auto-detect), or project parameter, leaving three of four parameters without meaning beyond their names.

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 specific verb and resource ('Transcribe an asset') and adds the distinguishing output trait 'word timestamps', which separates it from get_transcript (reading) and import_transcript (bringing in existing transcripts). It stops short of explicitly naming those siblings as alternatives, but the object 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?

It states the prerequisite ('needs pip install reelwright[transcribe]') and the follow-up pattern ('Results are cached; read them with get_transcript'), so an agent knows both what to install and what to call next. No explicit when-not guidance or cost/runtime expectation 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 behavioral burden. It does disclose one important side effect (subsequent clips shift), but says nothing about whether trims are undoable, what happens if only one of src_in/src_out is supplied, what units are used, or what the tool returns on success or failure.

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 the core operation front-loaded and zero filler. The phrasing 'Later clips ripple' is slightly cryptic, but nothing is 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?

For a mutation tool with no annotations, no output schema, and zero parameter descriptions, this definition is thin. The ripple behavior is the only behavioral disclosure; units, optional parameter semantics, failure modes, and reversibility are all 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?

Schema description coverage is 0%, so the description must compensate for four undocumented parameters. It only clarifies that the in/out points are in source time, leaving the units (seconds vs. frames), the nullability/default behavior of src_in and src_out, and the roles of project and clip_id entirely to inference.

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 specific verb ('Change') and resource ('a clip's in/out points') plus a disambiguating qualifier ('source time'), which clearly separates it from move_clip and split_clip. It stops short of naming those siblings explicitly, so it is clear but not fully differentiated.

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

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

The clause 'Later clips ripple' implies this is a ripple-trim operation with downstream consequences, which is useful context for choosing it over split_clip or delete_range. However, there is no explicit when-to-use/when-not guidance and no mention of prerequisites or how to avoid the ripple effect.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses almost nothing: not whether the undo is itself reversible via redo, what happens if there is no prior edit, whether history is shared or per-project, or what the response contains. Only the single-step scope is inferred from 'the last edit'.

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

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

One front-loaded sentence with no filler, so nothing is wasted, but it is under-specified rather than appropriately sized for a tool with zero annotation and zero schema-description coverage.

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 (one parameter, no nested objects, no output schema), so a short description is defensible, but with no annotations and 0% parameter coverage the agent is left guessing about the 'project' argument format and the failure behavior of undo.

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 sole required parameter 'project' is never mentioned in the description. It is unclear whether this is a project ID, name, or whether it selects which project's undo stack is popped — a meaningful ambiguity for an undo operation.

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

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

States a specific verb and resource ('Undo the last edit'), and 'the last edit' scopes it to a single-step reversal, which distinguishes it implicitly from the sibling 'redo'. It stops short of explicitly naming redo/history as the alternatives, so it falls just below the top score.

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

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

There is no when-to-use guidance beyond the implicit semantics of the word 'undo'. The description never mentions the sibling 'redo', never says whether repeated undos are possible, and gives no preconditions (e.g., that edit history must exist).

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 not disclose whether the operation is destructive or reversible, whether settings not supplied are preserved (nulls default to null in the schema), what permissions are needed, or what the call returns. 'Change' implies mutation but the description says nothing about the effect on existing canvas state.

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

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

A single front-loaded sentence with no filler, and the affected settings are grouped in parentheses for quick scanning. It is efficient rather than padded, though the brevity is part of why the semantics are thin.

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

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

For a seven-parameter mutation tool with no annotations, no output schema and zero schema coverage, the description is under-specified: partial-update semantics, the required project scope and value formats are all missing. It is adequate to recognize the tool's purpose but not to invoke it correctly without trial and error.

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, and it only partially does: it names fit, fps, background and font_file and clarifies font_file applies to text, but adds no value formats (hex colour, fps range, pixel units) and never explains the required 'project' parameter. Five of seven parameters get a bare mention and none get semantics beyond their names.

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 ('Change') and resource ('canvas settings') and enumerates the affected fields (resolution, fps, fit, background colour, font file), so it is clearly distinguishable from every sibling tool. It loses a point because 'resolution' is not explicitly mapped to the width/height parameters and the required 'project' argument goes unmentioned.

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

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

There is no when-to-use guidance, no statement of prerequisites, and no indication of whether this is a full replacement or a partial patch of settings. The agent is left to infer that omitted parameters stay unchanged, which is a meaningful behavioral decision for a settings 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 entire behavioral burden, and it discloses almost nothing. It does not say whether omitted parameters leave values unchanged or reset them to the schema null defaults, nor whether changes require specific permissions or are undoable (the sibling 'undo' hints at a stack but it is not stated).

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

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

It is a single front-loaded sentence with no wasted words, so it is structurally clean. The brevity comes at the cost of specification rather than from efficiency, which keeps it out of the upper range.

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 nine-parameter mutation with no annotations, no output schema, and zero schema descriptions, a one-line description is drastically inadequate. An agent cannot safely determine what each argument does or how partial updates behave from this definition 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% across 9 parameters, so the description must compensate and instead adds nothing. Text, color, font_size, position, box, start and end, and the required project/overlay_id identifiers are never explained, and the critical partial-update semantics of the nullable defaults are left 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 verb 'Change' plus the resource 'a text overlay' identifies the operation and implicitly separates it from siblings add_text and remove_text. But 'any property' is vague hand-waving rather than a statement of what is actually being modified, and the agent gets no sense of scope or limits.

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

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

There is no when-to-use guidance, no mention of alternatives (remove_text to delete, add_text to create), and no stated prerequisites such as whether the overlay must already exist or whether a render is needed afterward. Usage is only inferable 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.