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

With no annotations provided, the description carries the full burden. It states the action but fails to disclose potential side effects (e.g., overwriting existing markers), prerequisites (e.g., an open timeline), or return behavior. This lack of detail leaves the agent uncertain about the tool's operational 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?

The description is a single, focused sentence that gets straight to the point. It uses an active verb and communicates the core function without any extraneous words or details.

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

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

For such a simple tool, the description is minimally adequate—it states what it does and where. However, it omits any mention of return values, success/failure indicators, or required timeline state, which could be important in a larger workflow. The presence of an output schema is noted but not detailed in the description, so the agent is not fully informed.

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

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

The schema provides no per-property descriptions, so the description must clarify all parameters. It only explains 'frame' as the frame number, leaving 'note' and 'color' unexplained. While their names and defaults are suggestive, the description does not compensate for the schema's low coverage.

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

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

The description clearly states the verb 'Adds' and the specific resource 'editorial marker' with location 'on the timeline at the given frame number'. This leaves no ambiguity about the tool's purpose and distinguishes it from sibling tools that analyze or build beat-synced reels.

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 guidance on when to use this tool versus alternatives such as davinci_build_beat_synced_reel or davinci_analyze_audio_beats. The description implies usage for placing a marker at a specific frame, but it does not mention any conditions or 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?

There are no annotations to clarify side effects, and the description only says 'Displays' without explaining whether the cursor is actually moved, whether the badge persists, or what happens to a previously displayed badge. The name 'cursor_move' implies movement, but the description only mentions displaying a badge, leaving ambiguity.

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

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

The description is a single, compact sentence with no unnecessary wording. It directly states the action, object, and location.

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 and no usage context, the description leaves out important operational details such as side effects, success or failure conditions, and interaction with the UI. An output schema exists, so return values are not the main gap, but the lack of behavioral context is significant for a tool that interacts with a video editor interface.

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

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

The description explicitly maps x and y to coordinates, which adds meaning beyond the bare schema. However, the 'label' parameter is not mentioned in the description, and there are no parameter descriptions in the schema, so it is not fully covered.

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

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

The description clearly states the action ('Displays') and the object ('virtual glowing AI cursor badge') at a specific location ('coordinates (x, y)'). It distinguishes itself from sibling tools like ghost_click or transport by focusing on a visual cursor badge, though it does not explicitly address the 'move' in the tool 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?

No guidance is provided about when to use this tool versus alternatives such as ghost_click, seamless_click, or micro_adjust. There is no mention of use cases, preconditions, or situations where this badge display would be appropriate.

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

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

With no annotations, the description carries the full burden. The verb 'Analyzes' clearly indicates a non-destructive, read-only operation, though it does not explicitly mention side effects, permissions, or that it does not modify the audio.

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

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

The description is a single, focused sentence with no filler, immediately conveying the tool's purpose. It is concise and well-structured.

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

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

While the description is clear for a simple analysis tool, it omits what the tool returns (e.g., beat timestamps or cut points) and any prerequisites like having an audio track imported. The presence of an output schema is noted but not shown, so the description alone is not fully complete for an agent to use the tool correctly.

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

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

Schema description coverage is 0% and the tool description does not explain any of the parameters (audio_path, fps, max_duration_seconds). The names are somewhat self-explanatory, but the description fails to compensate for the missing schema details, leaving their roles ambiguous (especially fps).

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 ('Analyzes') and describes the exact scope (tempo, downbeats, musical bars, frame-locked cut points) for rhythmic video editing, clearly distinguishing it from sibling tools that build reels or add markers.

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

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

Implies usage for rhythmic video editing, but does not explicitly state when to prefer this tool over alternatives like davinci_build_beat_synced_reel or davinci_add_beat_marker. No direct guidance on conditions or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action (apply or synthesize) without revealing side effects, required setup, error conditions, or whether the operation modifies the node destructively. The 'Antigravity look preset' synthesis is particularly opaque, and no details about the effect on the clip or node are 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?

The description is a single sentence, which is concise and front-loaded with the primary verb and object. However, the disjunctive 'or synthesizes an Antigravity look preset' adds confusion and reduces clarity, but the overall length is appropriate for the level of detail. It is not verbose, so it earns a high conciseness score despite the ambiguity.

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

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

Given the tool's complexity (3 parameters, no annotations, and an ambiguous alternative action), the description is incomplete. It does not explain when to use the synthesis mode, what happens to the clip, or any prerequisites. While an output schema exists (not shown), the description still lacks essential context for correct invocation, such as the need for a selected clip or how node_index interacts with the timeline.

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% (the schema only provides names and types like 'lut_path' as a string, no descriptions). The description does not elaborate on any parameter—it does not explain what lut_path should reference, how clip_index identifies a clip, or the meaning of node_index. This is a critical gap since the schema offers no semantic information and the description adds none.

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

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

The description states a clear primary action: 'Applies a 3D LUT (.cube) to a clip node.' This distinguishes it from siblings like davinci_list_luts (listing LUTs) and davinci_generate_and_install_lut (creating LUTs). However, the appended alternative 'or synthesizes an Antigravity look preset' introduces ambiguity—it is unclear what triggers this synthesis or how it differs from applying a LUT, slightly diminishing clarity.

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 guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., a clip must be loaded) or when the synthesis path applies. Sibling tools like davinci_generate_and_install_lut exist but no comparison or routing is provided, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description carries the full burden of transparency. It mentions actions like 'injects' and 'loads sequence' but does not disclose potential side effects, reversibility, or impacts on existing timeline content. The description does not warn about destructive or irreversible changes.

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

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

The description is concise, using a clear numbered list to outline the tool's actions. It avoids unnecessary filler and presents the main function upfront, making it easy to scan. No redundant or verbose phrasing is present.

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

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

While the description gives a good overview of the tool's capabilities, it lacks context about prerequisites (e.g., whether media must already be imported or if a timeline must exist), and it does not mention any side effects or required environment state. Since an output schema exists, return-value details are not needed, but the absence of surrounding context leaves some gaps.

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

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

The schema has 0% description coverage, and the description only partially clarifies some parameters. It mentions pacing values ('rapid', 'standard', 'bars') and effects_style values ('comic_dynamic', 'high_energy', 'subtle') but leaves timeline_name, audio_path, clip_paths, fps, and color_preset unexplained beyond their names. The description does not fully compensate for the missing schema descriptions.

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

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

The description clearly states the tool's main function: 'Autonomously constructs and injects a 1080x1920 vertical beat-synced reel into DaVinci Resolve' and enumerates specific steps. It is distinct from siblings like davinci_analyze_audio_beats or davinci_add_beat_marker by focusing on the full assembly of a reel.

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

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

The description implies this tool is for constructing a complete beat-synced reel (as opposed to individual editing steps), but it does not explicitly mention when to choose it over other tools or provide any alternative guidance. The usage is only implied by the scope of the described actions.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states 'creates or configures' but does not explain side effects, whether it overwrites existing projects, if any state is required, or what the response contains. For a mutation tool, this is insufficient.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately concise, though the lack of detail reduces its effectiveness. Structure is fine but content could be richer.

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 an output schema, which might cover return values, but the description does not reference it or explain what 'configure' entails. For a creation tool, it is missing crucial behavioral details like whether it creates a new project or modifies an existing one, and how the project is identified. The description is incomplete for safe usage.

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 parameters. It mentions frame rate and its default (24fps) but does not explain the 'project_name' parameter beyond its name. The description adds some meaning for fps but fails to clarify the required project_name, leaving it ambiguous.

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

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

The description clearly states the tool creates/configures a 9:16 vertical project with specific resolution and frame rate. The verb 'creates or configures' is specific, though 'configures' is slightly vague. It distinguishes from siblings like create_vertical_timeline by focusing on project creation, but does not explicitly contrast with them.

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

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

No guidance on when to use this tool vs. alternatives such as davinci_create_vertical_timeline or davinci_set_vertical_resolution. There is no mention of prerequisites, when to choose this over others, or exclusions.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It reveals that the tool mutates state by creating a timeline and arranging clips, but it does not disclose prerequisites, side effects on existing timelines, error behavior, or whether media must already be imported. For a mutation tool this is a significant transparency gap.

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

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

The description is a single focused sentence with no filler. It front-loads the core action and resolution, and every word contributes meaning.

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

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

With 4 parameters, no annotations, and 0% schema coverage, the description is too thin for an agent to call the tool reliably. It omits parameter semantics, prerequisites, and any workflow context. The presence of an output schema helps with return values but does not compensate for the missing operational guidance.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It only hints at clip_names through 'designated clips' and never explains audio_path or clip_duration_frames. An agent cannot infer what audio_path expects or what clip_duration_frames controls from this text.

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

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

The description clearly states a specific verb ('Creates'), a specific resource ('new 1080x1920 vertical timeline in DaVinci Resolve'), and an additional behavior ('arranges designated clips'). It also distinguishes itself from siblings like davinci_create_vertical_project, which creates a project rather than a timeline.

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

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

The description implies the tool is used when a new vertical timeline should be created and clips placed on it, but it gives no explicit when-to-use guidance, prerequisites, or exclusions. Since davinci_create_vertical_project exists as a close sibling, explicit routing between project creation and timeline creation would be valuable.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It states the core behavior (synthesize and install) and specifies the target directory, which implies a filesystem write. However, it does not disclose potential side effects (e.g., overwriting existing LUTs, requiring application restart, affecting current project) or any prerequisites. This is moderately transparent but leaves significant gaps given the absence of annotations.

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

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

The description is extremely concise—two sentences—with the primary action front-loaded. It lists presets in a compact, scannable line. There is no redundancy or fluff; every word earns its place.

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

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

This is a complex tool that writes to the filesystem and has side effects. The description fails to mention prerequisites (e.g., DaVinci Resolve installed and running), potential overwrite behavior, whether a restart is needed, or what the return value indicates. While an output schema exists, the description does not reference it or summarize what the tool returns. Given the tool's complexity, the description is insufficient for an agent to confidently invoke it without risking unintended consequences.

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 explain the parameters. It lists six possible preset values (comic_noir, kodak_2383, etc.) but does not explicitly tie them to the preset_name parameter, and it completely ignores the size parameter. There is no explanation of what size means (e.g., LUT grid resolution) or its effect. The description compensates only partially for one parameter and not at all for the other.

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

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

The description clearly states the tool synthesizes a 3D .cube LUT and installs it into a specific directory. It names the exact resource and action, and it distinguishes itself from sibling tools like davinci_apply_lut (which applies an existing LUT) and davinci_list_luts (which lists LUTs). No ambiguity remains.

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

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

The description implies usage (generate and install a new LUT) but never explicitly states when to choose this over alternatives. It does not mention exclusions, such as 'if you want to apply an existing LUT, use davinci_apply_lut' or 'if you only need to list LUTs, use davinci_list_luts.' The context is clear enough that an agent could infer, but explicit guidance is absent.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The term 'background click message' hints at non-intrusive behavior but doesn't explain what 'background' means, whether it requires window focus, if it is asynchronous, or any side effects. This is a significant gap for a tool that interacts with UI.

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

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

The description is a single, front-loaded sentence with no wasted words. It clearly states the action and parameters without extraneous details.

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

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

For a simple two-parameter tool, the description covers the basics, but it lacks differentiation from similar click tools (seamless_click, ai_cursor_move) and doesn't explain the 'background' aspect. While an output schema exists (not shown), the description doesn't mention expected outcomes or return values. It's minimally sufficient but not comprehensive.

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 does add meaning by specifying that x and y are 'window coordinates', which clarifies they are not screen or global coordinates. However, it doesn't specify units, origin, or any constraints beyond that. This provides minimal but useful context.

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

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

The description clearly states the action: it dispatches a click message to DaVinci Resolve at specific coordinates. The verb 'dispatches' and resource 'DaVinci Resolve' are specific. It does not explicitly differentiate from sibling tools like davinci_seamless_click or davinci_ai_cursor_move, but the core 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 tool versus alternatives such as davinci_seamless_click or davinci_ai_cursor_move. The description only states what it does without any context on preferred scenarios, prerequisites, or exclusions.

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

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

The description reveals the side effect of downloading and extracting audio for YouTube URLs, but it does not clarify whether the tool is read-only or mutates the project state (e.g., adding media to the timeline). Without annotations, the description carries the full burden but only partially addresses this.

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

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

The description is extremely concise, consisting of two short sentences that convey the essential information without any unnecessary words. The structure is efficient and easy to parse.

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

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

Given the wide range of sibling tools (e.g., import_media, smart_ingest, analyze_audio_beats), the description does not differentiate this tool from alternatives or mention when it is the appropriate choice. It also omits any information about return values or error handling, but the core function is clear enough for basic use.

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

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

The description implicitly refers to path_or_url as either a file path or YouTube URL, but it does not explicitly explain either parameter. The destination_folder parameter is not mentioned at all, leaving its role unexplained. Since the schema provides no descriptions, the tool description fails to adequately document the parameters.

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

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

The description clearly states the tool's primary function: importing an audio file into DaVinci Resolve. It also explicitly covers the special case of YouTube URLs, which includes downloading and extracting 48kHz WAV audio, leaving no ambiguity about the tool's purpose.

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

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

The description provides some usage guidance by mentioning the YouTube URL scenario, but it lacks explicit instructions on when to choose this tool over siblings like import_media or smart_ingest. No prerequisites or context are given beyond the core function.

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 present, the description carries the full burden of explaining side effects. It only states the basic import action without mentioning whether bins are created, whether existing clips are duplicated, error handling for missing files, or any state changes beyond adding media.

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

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

The description is a single, concise sentence with no redundancy. It front-loads the primary action and includes only essential details, making it easy to scan and understand.

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

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

The description adequately states the core function but omits important context such as expected output, failure modes, or relationship to sibling import tools. Given the moderate complexity and lack of annotations, it is minimally complete but not richly contextual.

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

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

The schema has no parameter descriptions, so the tool description must compensate. It clarifies that file_paths are local disk paths and bin_name is the target bin, adding some meaning. However, it does not specify path formats, supported file extensions, or behavior when bin_name is omitted, leaving 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 clearly states a specific action ('imports'), the resource type ('video/audio clips'), and the destination ('a designated Media Pool bin'). It effectively distinguishes this tool from sibling tools like davinci_import_audio and davinci_smart_ingest by focusing on general media import.

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

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

No guidance is provided on when to use this tool instead of alternatives such as davinci_smart_ingest or davinci_import_audio. The description lacks context about preferred scenarios, prerequisites like existing bins, or when the default bin_name would be appropriate.

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

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

No annotations are provided, and the description does not disclose whether the operation is read-only, if it has side effects, or if it requires any permissions. It only mentions capturing and analyzing, leaving behavioral aspects unclear.

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

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

The description is a single, concise sentence that efficiently communicates the tool's function. It is well-structured and easy to parse.

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

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

The description covers the core action but does not mention expected output, return value, or any prerequisites. For a simple inspection tool, this may be sufficient, but it could be more complete.

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

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

The description explains that x and y define the center of the crop region, providing some semantic meaning beyond the raw integer types. However, it lacks details on units, coordinate system, or valid ranges.

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

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

The description clearly states the tool captures a micro-crop region and analyzes waveform/visual contrast, which differentiates it from sibling tools like transport or adjustment. However, it could be more explicit about the intended use case.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any conditions or scenarios that would favor this tool.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. The verb 'Lists' strongly implies a non-destructive read operation, and 'currently installed' conveys a snapshot of current state. However, it does not explicitly state that no modifications occur, whether DaVinci Resolve must be running, or any potential side effects.

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

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

A single, tightly worded sentence that front-loads the action ('Lists') and includes all essential scope details without filler. Every word earns its place.

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

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

The description covers the core purpose and scope fully. With an output schema present, return values are presumably defined elsewhere. The only missing context is an explicit statement about when to use this versus applying or generating LUTs, but for a simple list operation the definition is largely complete.

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

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

The tool has zero parameters, so there is nothing for the description to explain beyond the schema. The baseline for 0-parameter tools is 4, and the description adds no unnecessary parameter information.

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 ('Lists'), a specific resource ('Antigravity LUTs'), and a precise location ('DaVinci Resolve's native system directory'). This clearly distinguishes it from sibling tools like davinci_apply_lut and davinci_generate_and_install_lut, which perform different actions on LUTs.

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 usage context is implied: use this tool to discover installed LUTs. However, it does not explicitly mention when to choose this over alternatives or any exclusions, such as 'use apply_lut to apply a LUT' or 'use generate_and_install_lut to create one.' No alternative routing is provided.

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

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

No annotations are provided, and the description does not disclose whether the operation is destructive, whether it can be undone, whether it affects only the clip or the timeline, or what side effects it may have on the 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?

The description is a single clear sentence with no unnecessary words or filler. It is appropriately brief for its level of abstraction.

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

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

The description is extremely minimal. It omits output/return behavior, parameter meaning, effect details, error handling, and any operational context needed to confidently invoke or interpret the result.

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

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

The description does not explain any parameter semantics. The schema only provides names like zoom, pan_x, pan_y, opacity, rotation, and clip_index, leaving their units, ranges, effect directions, and mutual dependencies entirely unspecified.

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

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

The description identifies the target (clip on Video Track 1, 1-based index) and the action (performs micro-framing), but the term 'micro-framing' is vague and does not explicitly state what is adjusted (e.g., zoom, pan, opacity, rotation) even though the schema suggests those fields.

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

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

No guidance is provided about when to use this tool versus sibling tools such as davinci_apply_lut, davinci_build_beat_synced_reel, or davinci_transport. There is no mention of intended workflow, limitations, or prerequisites beyond the schema.

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 only says 'queues and triggers' and omits whether the call blocks, how long it may run, whether existing files are overwritten, or failure behavior.

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

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

Single concise sentence that immediately conveys the tool's core action and output format/resolution.

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

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

Adequate for basic selection but lacks operational context such as output behavior, preconditions, and relation to render status/transport 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 provides no parameter descriptions and the description does not explain output_dir or filename beyond their names, missing details like required extension or path expectations.

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

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

Clearly states the tool queues and triggers a specific render job with resolution and codec details, differentiating it from sibling tools like status or transport.

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

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

No guidance on when to use this render command relative to siblings or what preconditions (e.g., timeline ready, project loaded) should exist before invoking.

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

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

The description discloses some behavioral side effects: it clicks, emits glowing AI badge telemetry, and restores the mouse position. However, with no annotations, it does not mention potential failures, permissions, or other side effects.

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

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

The description is a single concise sentence that communicates the core behavior without unnecessary detail.

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

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

The description is sufficient for basic invocation with x and y, but the label parameter is unexplained and the relationship to similar sibling tools is not addressed. The output schema is noted as present but not detailed.

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 x and y parameters are reasonably explained by the description as click coordinates. The label parameter is present but completely unexplained, leaving ambiguity about its purpose and allowed values.

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

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

The description clearly states the action: performing a localized click at specific coordinates, with the additional behaviors of glowing AI badge telemetry and restoring the mouse position. It is specific enough to understand the tool's core purpose, though it does not explicitly distinguish it from ghost_click.

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

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

No explicit guidance is given about when to use this tool versus sibling tools like davinci_ghost_click or davinci_ai_cursor_move. The behavior of restoring the mouse position suggests a use case, but it is not stated.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'Enforces' and 'Project Settings' but does not disclose side effects, prerequisites (e.g., an open project), failure modes, or whether the tool modifies existing settings versus creating new ones.

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, succinct sentence that delivers the essential information without any unnecessary detail or verbosity.

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

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

Given the simplicity of the action (setting a fixed resolution), the description is adequate but lacks surrounding context. It does not mention return values, effects on the current project state, or any required prior steps, which could be important for an agent to use the tool safely.

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

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

The tool has zero parameters, so the description does not need to explain any. The fixed resolution is clearly stated in the description, providing sufficient meaning for a parameterless 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?

The description clearly states the tool's function: enforcing a specific canvas resolution (1080x1920, 9:16 vertical) in DaVinci Resolve Project Settings. It distinguishes itself from sibling tools by focusing on the resolution setting, not project creation or timeline setup.

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

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

The description does not provide any guidance on when to use this tool versus alternatives like davinci_create_vertical_project or davinci_create_vertical_timeline. It only states what it does, leaving the agent to infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden. It mentions using hardware GPU acceleration and automating file dialogs, but does not disclose side effects such as whether original files are preserved, or any potential system impacts. Transparency is moderate but incomplete.

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

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

The description is a succinct, well-structured list of three bullet points. It conveys the core functionality without unnecessary verbosity 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?

The description covers the main processing steps but does not mention the return value or output format, even though an output schema is indicated as present. It also omits error handling, prerequisites, or any caveats. For a multi-step tool, this is a noticeable gap.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explicitly explain each parameter. While folder_path is self-explanatory from its name, chunk_size and max_videos are not described in detail, and the description only vaguely mentions 'in chunks' without connecting it to the 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 states the tool's core purpose: high-performance smart ingestion for raw footage, with specific actions like transcoding HEVC to H.264, converting HEIC to JPEG, and automating file dialog in chunks. It uses specific verbs and distinguishes itself from generic import tools.

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

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

The description implies the use case (raw footage needing transcoding/conversion) but does not explicitly state when to use this tool over alternatives like davinci_import_media or davinci_import_audio. No conditions or contrast with siblings are provided.

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

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

With no annotations provided, the description carries the responsibility. It transparently states that the tool 'checks status' and returns information, implying no side effects. It does not explicitly guarantee a non-destructive operation, but the nature of a status check makes that clear.

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

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

The description is extremely concise—two sentences—and the key information is front-loaded. The first sentence states the primary action, and the second enumerates the returned data. No unnecessary words or filler.

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

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

The description fully explains what the tool does and what it returns. Given that there are no parameters and the output schema is provided externally, the description is complete enough for an agent to use the tool correctly without further clarification.

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

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

The tool has no parameters, so there is nothing to describe. The schema is fully covered (empty properties), and the description correctly omits any parameter details. This avoids ambiguity.

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

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

The description clearly states the tool's function: checking the status of DaVinci Resolve. It uses a specific verb ('checks') and resource ('DaVinci Resolve'), and lists concrete return values (window state, project title, coordinates, API connection). This distinguishes it from all sibling tools, which perform actions like switching pages or setting resolutions.

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 implicitly indicates when to use the tool: whenever the current state of DaVinci Resolve is needed. It does not explicitly mention alternatives or provide a 'use when' phrase, but the purpose is straightforward and self-evident given the tool's read-only nature.

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 bears full responsibility for behavioral disclosure. It only says 'switches' a page, implying a mutation, but doesn't disclose any side effects, required state (e.g., whether Resolve must be running), or reversibility. This is a minimal level of transparency.

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

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

The description is a single, front-loaded sentence that states the verb and resource first, then lists valid values. There is no filler or redundancy; every word contributes to understanding the tool's purpose and parameters.

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

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

Given the tool's simplicity (one parameter, no annotations, output schema exists but not critical for invocation), the description provides all necessary information: what it does, what values the parameter accepts, and the expected effect. Nothing essential is missing.

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

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

The input schema has a single required string parameter 'page' with zero description coverage and no enums. The description compensates fully by listing all accepted values ('media', 'cut', 'edit', 'fusion', 'color', 'fairlight', 'deliver'), which is exactly the semantic meaning an agent needs. This adds significant value beyond the bare schema.

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

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

The description clearly states the action: 'Switches DaVinci Resolve workspace page' and enumerates all valid page values ('media', 'cut', 'edit', 'fusion', 'color', 'fairlight', 'deliver'). This specific verb+resource makes it unambiguous and distinct from sibling tools, which all handle different actions.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of contexts, prerequisites, or exclusions, so an agent must infer usage from the tool's name and siblings. The description only states what the tool does, not when to pick 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?

There are no annotations and the description only lists command names, failing to disclose potential side effects like timeline changes, playback state modifications, or dependence on a running application. This limits the agent's ability to predict the tool's impact, especially since it executes shortcut-like actions.

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

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

The description is a single, focused sentence that lists all relevant actions without any fluff. It is well-structured and immediately conveys the tool's scope, making it easy to scan and understand.

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

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

Given the tool's simplicity (single parameter, no output schema), the description provides sufficient context for basic usage. It lacks details about return values or broader workflow integration, but that is not critical for a transport command. It is mostly complete.

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

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

The schema provides only a required string 'action' with no enum or description (0% coverage). The description compensates by enumerating valid values ('play', 'pause', 'toggle', etc.), giving the agent concrete parameter options. However, it does not explain what each action does, so it is not fully comprehensive.

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

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

The description clearly states the tool's purpose with a specific verb ('Executes') and identifies the resource ('playback, cutting, and timeline navigation shortcuts'), listing concrete actions. It is easily distinguishable from sibling tools that perform different tasks like status checks or page switches.

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 explicit guidance on when to use this tool versus alternatives. It simply lists available shortcuts without explaining conditions or contexts, leaving the agent to infer when transport actions are appropriate compared to other davinci_* tools.

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