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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals only that this is a mutating operation ('create') but says nothing about behavior on duplicate folder names, how a nonexistent parent is handled, whether nesting is supported, or project-state requirements. Minimal, not misleading, but far from transparent.

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 six-word, single sentence that is front-loaded and contains no filler. Every word earns its place. It loses a point only because the brevity reflects thin informational content rather than efficient compression of rich 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?

Though the tool is low-complexity (2 params, 1 required, no enums), the absence of annotations and 0% parameter coverage leaves key gaps: the meaning of 'parent', prerequisite project state, and error/failure behavior. An agent cannot reliably construct a correct call, particularly for the optional parent parameter, from the description alone.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not explain what 'name' constraints apply or what 'parent' means (parent folder path? ID? does null mean the bin root?). The property names and default value are mildly self-descriptive, but the agent is left guessing about the parent parameter's format and semantics.

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?

'Create folder in project bin.' states a specific verb (create), resource (folder), and location (project bin). Among the sibling tools, the bin_* family handles clips (import, list, remove, move) and renaming, so the folder-creation purpose is distinguishable without opening the schema. It stops short of a 5 because it doesn't explicitly contrast with any sibling or clarify folder hierarchy semantics.

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

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

The description gives no guidance on when to use this tool vs alternatives such as bin_rename or bin_import_clip, no prerequisite conditions (e.g., whether a project must be open), and no exclusions. An agent must infer the appropriate invocation context entirely from the tool name and sibling list.

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

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

No annotations are provided, so the description carries the full burden. The verb 'Get' reasonably implies a non-mutating read operation, and the listed property categories give some behavioral context. However, it does not address prerequisites, error behavior, or whether the operation has any side effects.

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

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

The description is short and front-loaded with the main purpose, followed by a single parameter explanation. There is no unnecessary filler, though the Args formatting could be tightened; overall every line 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?

Given the tool is a simple one-parameter getter with an output schema available, the description covers purpose, parameter semantics, and result categories. The main gap is lack of differentiation from clip_get_properties and any stated state requirements, but for its low complexity it is reasonably complete.

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

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

Schema description coverage is 0%, so the description must define clip_id on its own. It does so clearly: 'The clip identifier from the bin.' This adds source and scope beyond the bare schema type. It could mention the expected format, but for a single required parameter it is sufficient.

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 states a clear action ('Get detailed properties') and resource ('a bin clip'), with concrete examples of the data returned (length, aspect ratio, media info). It is unambiguous but does not explicitly distinguish itself from the similarly named sibling clip_get_properties.

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 for when to use this tool versus clip_get_properties or other clip/bin tools. There are no exclusions, prerequisites, or alternative suggestions, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does add useful behavioral context: name defaults to filename, duration defaults to an ffprobe auto-probe, and clip_type acts as a media-type hint. However, it does not disclose side effects of importing (e.g., whether the file is copied or referenced, overwrite behavior on name collision, or failure behavior for invalid paths).

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

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

One purpose sentence followed by a tight Args block. Every line earns its place, the core action is front-loaded, and the parameter explanations are compact without redundancy.

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

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

Given an output schema exists (so return values are covered elsewhere), the description is nearly complete for a 4-parameter import tool. It documents all parameters meaningfully and covers defaults and the ffprobe probing behavior. Minor gaps are the lack of edge-case/error handling and no mention of what happens on re-importing the same path.

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 fully compensate, and it does. Every parameter is explained with meaning beyond the bare schema: clip_path's accepted media kinds, name's fallback behavior, duration's units and image-specific use, and clip_type's role as a hint.

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 ('Ingest') and a clear resource ('media file into the project bin'), and states the purpose ('for later timeline use'). It is readily distinguishable from the other bin_* siblings (bin_remove_clip, bin_list_clips, bin_get_clip_details), which perform clearly different operations.

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

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

The description implies when to use the tool via the phrase 'Ingest a media file into the project bin' and the supported media types (video, audio, image). However, it never explicitly states when not to use it, mentions no exclusions, and does not reference alternative tools such as timeline_add_clip or bin_move_clip.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, which is consistent, but the description does not add behavioral context beyond that — no statement about read-only safety, empty-bin behavior, or whether nested folder assets are included. The output schema may cover return structure, but edge behavior is left undisclosed.

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

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

A single 12-word sentence that front-loads the verb and scope, then specifies the returned fields. Every word earns its place; there is zero redundancy or filler.

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

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

For a zero-parameter listing tool with an output schema present, the description is nearly complete: it states exactly what the agent will receive without needing to pass anything. The only gap is the absence of routing context toward sibling tools, but that gap is minor given how simple and self-contained this tool 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?

The tool takes zero parameters, so there is nothing for the description to explain. Per the baseline for 0-param tools, a 4 is appropriate; the description correctly focuses on what the tool returns rather than inventing parameter detail that does not exist.

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 ('List') tied to a clear resource ('every asset in the project bin') and enumerates the exact fields returned: ID, name, type, and duration. This clearly differentiates it from siblings like bin_get_clip_details (single-clip detail retrieval), bin_import_clip, and bin_remove_clip, which operate on individual clips rather than enumerating the whole bin.

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 'List every asset' implies a broad enumeration use case, so an agent can infer when to reach for it versus single-clip tools. However, there is no explicit when-to-use guidance, no exclusion of alternatives, and no mention of bin_get_clip_details or clip_get_properties as the right choice when only one clip's details are needed.

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 transparency burden. It does disclose the root-if-None behavior beyond the schema, and 'move' implies removal from the source location. It does not mention failure modes, permissions, or whether the target folder must already exist.

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

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

A single, front-loaded sentence with no wasted words. The conditional root behavior is packed into a short parenthetical, preserving both clarity and brevity.

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 with an output schema, the description is mostly adequate. The main gap is the underspecified folder parameter, which could lead an agent to pass the wrong value type. The description could be complete with one more clause about folder format or validation.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by clarifying that folder=None targets the root, which the anyOf schema does not convey. However, it leaves clip_id and the expected format of the folder parameter (ID vs name, existing folder) unexplained.

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

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

The description names a specific verb ('Move'), a resource ('clip'), and a destination ('folder' or root). It is unambiguous as a bin operation, though it does not explicitly contrast with sibling tools like timeline_move_clip.

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 action itself implies when to use it, but there is no explicit guidance about alternatives or non-use cases. The parenthetical 'or root if folder None' is more about parameter behavior than usage context.

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

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

With no annotations, the description must disclose behavior; it only states the deletion action without mentioning side effects, error cases, or whether the operation is reversible. It does not contradict annotations (none provided).

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, front-loaded with the primary action, and includes a clear Args section. No wasted words.

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

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

For a one-parameter deletion tool with an output schema, the description covers the essential information: what it does, the parameter, and its source. Minor gaps like error handling are understandable given the simplicity.

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 clip_id is the identifier from bin_list_clips or bin_import_clip, adding context beyond the schema's bare string type. This helps the agent know how to obtain a valid ID.

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

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

The description clearly states the action (delete) and the specific resource (clip from media bin) using its ID. This distinguishes it from sibling tools like bin_move_clip or bin_rename.

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 its use for deleting a clip but provides no explicit guidance on alternatives or conditions. There is no mention of when not to use it or prerequisites, leaving usage to inference.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states that a rename happens, but it does not disclose potential side effects, validation rules, uniqueness constraints, or whether existing references to the clip are updated. The behavioral information is minimal.

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

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

The description is a single short sentence with no filler, which makes it easy to parse and front-loads the core action. While it is arguably under-specified, as a conciseness measure it is appropriately compact for a simple 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?

The presence of an output schema reduces the need to describe return values, but the description still omits important invocation context: where clip_id comes from, what constraints apply to new_name, and whether the rename affects other parts of the project. The tool is minimally viable, but not complete for reliable agent 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?

Schema description coverage is 0%, and the description 'Rename bin clip.' adds no meaning about the two required parameters, clip_id and new_name. The agent must rely entirely on their names and titles, which is insufficient compensation 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 uses a specific verb ('Rename') and a clear resource ('bin clip'), making the core operation unambiguous. It is naturally distinct from sibling tools like bin_import_clip and bin_remove_clip, but it does not explicitly call out scope or exclusions, so it stops short of a 5.

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

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

The description implies the tool should be used when renaming a clip in the bin, but it gives no explicit guidance about when to use it versus alternatives, nor does it mention prerequisites such as obtaining clip_id from bin_list_clips. The intended use case is inferable, 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 of behavioral disclosure. The 'Add / update' phrasing does signal an upsert-like mutation, but it does not say whether an existing note is overwritten, whether an empty string clears the note, or what happens when clip_id is invalid.

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 the core operation front-loaded and no filler. Every word contributes to meaning, making it appropriately sized for the tool's simplicity.

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 low complexity with two simple string parameters and an output schema, so a detailed return-format explanation is unnecessary. However, because there are no annotations and no usage or note-clearing semantics, the description is only minimally complete for safe invocation.

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

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

Schema description coverage is 0%, and the description adds almost no parameter-level meaning beyond the self-explanatory names 'clip_id' and 'note'. It hints that clip_id refers to a bin clip, but it does not clarify note format, length, clearing behavior, or where to obtain a valid clip_id.

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

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

The description states a clear action ('Add / update') and a distinct resource ('note for bin clip'), so an agent can tell this apart from the many timeline and clip tools in the sibling list. It does not explicitly contrast with a sibling, but the unique 'note' target and 'bin clip' scope make the purpose unambiguous.

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

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

There is no guidance on when to use this tool, whether the clip must already exist in the bin, or how it relates to other clip operations. The sibling list shows many clip-related alternatives, but the description never explains why an agent should choose this one over another.

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

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

No annotations are present, so the description must establish behavior on its own. 'Get' plus the property list makes clear this is a read-only query of clip attributes, not a mutation. It does not discuss edge cases or error conditions, but for a simple getter the core behavioral profile is transparent.

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 concise sentence front-loads the operation and follows with a colon-delimited list of returned properties. There is no filler and every word earns its place.

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

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

For a low-complexity getter, the description plus the output schema and self-explanatory parameter names cover the essential call contract. It lists exactly which properties are returned, and the output schema can handle structural details; the main remaining gap is explicit alternative 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% and the description adds no meaning for the two required parameters, track_id and clip_index, which are the only way an agent identifies which clip to inspect. The description does not even mention them, so it fails to 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?

Description names a specific operation ('Get') on a specific resource ('timeline clip') and enumerates the exact properties returned: in/out, duration, speed, opacity, reverse. This clearly differentiates it from sibling mutators like clip_set_speed, clip_reverse, and clip_set_opacity.

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 retrieval of clip properties, and the sibling list contains matching setters, so an agent can infer when to call it. However, it never explicitly says when to prefer this over related tools such as bin_get_clip_details or track_get_info, nor provides exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose the key stateful behavior ('toggles'), implying the operation switches reverse playback on and off and can be undone by calling it again. It does not mention output or wider side effects, but the simple action is reasonably transparent.

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

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

The description is a single compact sentence with no filler. The core action and the toggling qualifier are both front-loaded.

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

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

For a low-complexity tool with only two integer parameters and an output schema, the description provides enough to understand the core function. It is incomplete in not contextualizing the parameters and lacking usage guidance, making it adequate but not strong.

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

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

Schema description coverage is 0%, so the description needed to clarify track_id and clip_index, but it does not mention either parameter. The parameter names are somewhat self-explanatory in a timeline context, yet the description adds no parameter-level meaning.

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

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

The description uses a specific verb (reverse) and resource (timeline clip), and the '(toggles)' qualifier clarifies the exact behavior. It is readily distinguishable from sibling tools like clip_set_speed or timeline_seek, which address different clip/timeline properties.

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

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

No guidance is given about when to use this tool versus alternatives, nor any preconditions such as the timeline needing an active clip or the meaning of the indices. The word 'toggles' hints at behavior but not at 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 behavioral disclosure. While 'Set' and 'hex or named' give some signal, the description does not disclose whether the color label overwrites an existing one, whether changes are undoable, what named colors are acceptable, or how failures are reported.

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

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

The description is a single short sentence with no filler. The core action and target are front-loaded, and the parenthetical color-format note earns its place by adding the most useful parameter 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?

This is a simple two-parameter setter with an output schema present, so return-value details are not needed. The description plus schema is mostly sufficient for invocation, though a bit more context about color value constraints would round it out.

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 add meaning for 'color' by specifying hex or named formats, but 'clip_id' is left to inference from the tool name and the phrase 'bin clip', without any explicit guidance on how to obtain or format the identifier.

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 ('Set'), a specific resource ('color label'), and a scope ('bin clip'), which clearly differentiates it from sibling tools like clip_set_opacity, clip_set_speed, and bin_remove_clip. Adding 'hex or named' also clarifies the acceptable color input without ambiguity.

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

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

The description clearly indicates this tool is for bin clips, not timeline clips, which gives the agent useful context for selection among the many clip-related siblings. It does not explicitly state when to prefer an alternative, but no closely overlapping alternative exists, so the guidance is adequate.

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. 'Set' clearly indicates a mutation, but the description does not mention side effects, reversibility, error behavior, or any prerequisites. The opacity range hint is parameter knowledge, not behavioral 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?

A single sentence that immediately states the operation and the value range. Every word earns its place; there is no fluff, and the most important information is front-loaded.

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

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

For a mutation tool with no annotations and zero schema parameter coverage, this description is too thin. It omits parameter semantics for two of three parameters and gives no usage routing. The existence of an output schema lightens the need to document return values, but the behavioral and parameter gaps remain significant.

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

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

Schema description coverage is 0%, and the description only explains the opacity parameter with its range. It does not clarify how track_id and clip_index identify the target clip, leaving two of three required parameters semantically under-documented 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 clearly states the specific verb and resource: 'Set opacity of a timeline clip'. The parenthetical range (0.0 transparent .. 1.0 opaque) adds useful specificity. It is distinct from sibling tools like clip_set_color and clip_set_speed by the property it targets, though it does not explicitly name any alternatives, so it stops short of full sibling differentiation.

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

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

There is no guidance about when to use this tool versus other clip modification tools or timeline operations. The context of use is only implied by the tool's name and one-line description; no alternatives or exclusion criteria are mentioned.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does document the value semantics, including normal, fast, half-speed, and reverse behavior, but it does not mention bounds, clamping, persistence, or error handling for invalid speeds. This is adequate for a simple setter but not a complete behavioral profile.

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 an inline value legend. It is front-loaded with the action and contains no filler or redundant wording.

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, the description covers the critical domain knowledge: what speed values mean and how negative values behave. The main gaps are the lack of explicit explanation for track_id/clip_index and edge-case behavior, but the output schema exists and the overall operation is straightforward, so the definition is nearly 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 adds meaningful semantics for the speed parameter with examples like 1.0=normal and negative=reverse, which the schema leaves opaque. However, track_id and clip_index are only conveyed by their parameter names and integer types, receiving no explicit explanation, despite 0% schema description 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 and resource: set the playback speed of a timeline clip. It also explains the speed scale with concrete examples, but it does not explicitly differentiate this from sibling tools like clip_reverse or clip_set_opacity, so it falls just short of full differentiation.

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

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

No guidance is provided about when to use this tool instead of alternatives such as clip_reverse or when speed changes should be applied. The usage context must be inferred from the name and general mutation semantics.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'List' clearly implies a read-only operation, and the description states what is returned (all available render presets). However, it does not explain whether presets are global or project-specific, or whether any state changes occur, leaving some behavioral 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, focused sentence with no filler. It front-loads the action and scope, making it immediately scannable for an agent.

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

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

For a zero-parameter list tool with an output schema present, the description is largely complete. It could be slightly richer by clarifying how these presets relate to export_render or project_get_render_profiles, but nothing essential for invoking the tool is missing.

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

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

The tool has zero parameters and the input schema is fully transparent. No parameter-level explanation is needed, so the baseline of 4 applies; 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 states a specific verb ('List') and a clear resource ('render presets for final video output'), making the tool's purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like project_get_render_profiles or export_render, though 'render presets' and 'final video output' provide enough contextual separation.

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 'available render presets' implies this tool is for discovering presets before rendering, but there is no explicit statement of when to use it versus alternatives or any exclusions. Usage guidance is only inferred from the tool's name and simple description.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the external melt dependency and the pipeline from project to MLT XML to melt. However, it does not disclose whether rendering blocks, whether existing files are overwritten, or what side effects/return behavior occur after invocation.

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

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

The description is compact and front-loaded: a one-sentence summary, a two-sentence implementation note, a prerequisite, and a tight Args block. Every sentence adds value, and there is no redundant or filler content.

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

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

For a two-parameter tool with an output schema, the essential call shape is covered. Still, the description is incomplete in context: it does not explain how export_render relates to render_queue_* or whether this is a synchronous blocking operation, and it omits overwrite/side-effect behavior. An agent would need to infer these aspects from sibling names.

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

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

The input schema has 0% description coverage, but the Args section adds meaningful semantics: output_path is defined as the destination video file with an example, and preset is described as optional with a pointer to export_list_presets. This compensates well for the sparse schema, though it could be richer about accepted file extensions or preset value formats.

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: 'Render the project to a video file via melt.' It further clarifies the mechanism by stating it generates MLT XML and pipes it through melt, which clearly separates it from siblings like export_xml (XML output) and render_queue_* (queued 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?

The description implies its use for direct video rendering and provides a prerequisite ('Requires melt on the system') plus a cross-reference to export_list_presets for presets. However, it does not explicitly state when to use this tool instead of render_queue_add/start or export_xml, nor does it mention excluded scenarios.

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

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

No annotations are provided, so the description carries the behavioral burden. It does disclose the key default behavior (None means no file write and XML is returned in data.xml) and that a path causes a write, but it does not mention overwrite behavior, permissions, or whether XML is also returned when output_path is provided.

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

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

The description is compact and front-loaded with the tool's purpose before covering the argument. Every sentence adds information, with no filler or restatement of the tool name.

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

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

For a tool with one optional parameter and an output schema, the description covers the main calling concern and the None behavior. It could more explicitly state what happens in the non-None branch, but the overall guidance is sufficient for an agent to call it correctly.

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

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

Although schema description coverage is 0%, the description fully compensates by explaining the single parameter's type, giving a concrete file-path example, and specifying the exact behavior when output_path is None. This is materially more useful than the schema's bare title and 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, resource, and output format: 'Generate Kdenlive/MLT XML for the current project.' This clearly differentiates it from siblings like export_render and export_list_presets by output type, though it does not explicitly name the alternative tool to use for other export kinds.

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

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

Provides clear context by explaining the single optional argument and what happens when it is omitted (no file written; XML returned in data.xml). It does not explicitly state when to prefer export_xml over export_render, so no exclusion guidance is given, but the intended usage is easy to infer.

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 for behavioral disclosure. It states the basic attach action but does not say whether the effect is appended to an effect stack, replaces an existing effect, is immediately applied, or is undoable. For a mutating tool, this is a notable 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 compact: one framing sentence followed by a focused Args block. Every line adds value, and the examples and sibling pointer are included without unnecessary padding.

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 an output schema, the description covers all input semantics and gives enough detail to invoke the tool correctly. It would be fully complete if it noted how adding a filter relates to filter_set_param or whether filters are appended or replace existing ones.

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 fully compensates by documenting all four parameters. It adds crucial semantics: clip_index is 0-based, filter_type examples include frei0r.opacity, and params must be 'key=value' strings with a concrete example. This goes well 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 uses a specific verb ('Attach') and resource ('video/audio effect') for a timeline clip, making the core action clear. It does not explicitly distinguish itself from siblings like filter_set_param or transition_add, but the phrasing and examples leave the primary purpose unambiguous.

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

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

There is no when-to-use or when-not-to-use guidance relative to alternatives. The only sibling reference is 'Run filter_list_available for all options,' which helps enumerate filter names but does not explain when to choose filter_add over filter_set_param or filter_remove. The agent must infer the appropriate usage.

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

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

No annotations are provided, so the description must carry the burden of behavioral disclosure. The verb 'list' implies a read-only operation, but the description does not explicitly state that it has no side effects or what happens when the clip is invalid or has no filters. It is not misleading, but it leaves room for assumptions in 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 two concise sentences: the purpose sentence and a bulleted parameter explanation. It is front-loaded with the main action, uses no filler, and every word serves a purpose. Ideal length for a simple list 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?

While the description explains how to use the tool, it does not clarify how this differs from filter_list_available, which is a common source of confusion. It also does not mention that the tool returns only filters applied to that specific clip (vs. all available filters). Since the output schema exists, return details are covered, but the missing sibling differentiation is a contextual gap for the agent.

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 clarify the parameters. It does: 'track_id: Track containing the clip' and 'clip_index: 0-based clip index.' This adds meaning beyond the schema's bare titles, making it clear these are integer identifiers referencing the clip. The semantics are adequate for correct invocation.

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

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

The description states a clear verb and resource: 'List all active filters on a specific timeline clip.' It immediately distinguishes this from filter_list_available (which likely lists all filter types) and filter_add/remove (which modify filters). 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?

No guidance is given about when to use this tool versus siblings like filter_list_available or filter_set_param. The description only explains what it does, not the conditions that select it over alternatives. An agent must infer from the name alone, which is insufficient given the many filter-related 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?

There are no annotations, so the description carries full responsibility. The verb 'Discover' and the listing semantics imply a read-only operation, but the description does not explicitly state that no state changes occur or describe any other behavioral details such as return format. It is adequate but not particularly transparent.

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

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

The description is very concise, front-loads the primary purpose in one clear sentence, and then documents the only parameter without unnecessary filler. Every sentence contributes useful 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 simple one-parameter tool with an output schema, the description covers the core invocation needs. However, the lack of distinction from the sibling 'filter_list' and the absence of usage guidance leave an ambiguity that makes it incomplete from an agent's decision-making perspective.

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

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

The schema only provides type and default for the 'category' parameter, while the description adds meaningful semantics: it is an optional category filter and includes concrete examples like 'blur, color, audio'. The examples help an agent choose valid values despite the schema lacking enums.

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

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

The description clearly states the tool's action ('Discover') and resource ('all filters the Kdenlive runtime exposes'), making it easy to understand. However, it does not distinguish itself from the sibling tool 'filter_list', which may also relate to filters, so it stops short of full sibling differentiation.

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

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

No guidance is given about when to use this tool versus alternatives such as 'filter_list'. The description implies one use case (discovering available filters) but does not explain when to prefer this tool, when to avoid it, or how it differs from filter-related 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 present, so the description carries full responsibility for disclosing side effects. 'Detach' hints that the effect is separated from the clip but does not state whether the effect is deleted, persists elsewhere, or whether the operation is undoable; this ambiguity is a real transparency gap for a mutation tool.

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

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

The definition is a one-line purpose plus a compact args table with no filler; every sentence contributes. It is appropriately sized for a simple three-integer tool.

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

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

For a low-complexity removal tool with an output schema, the summary and parameter docs are mostly sufficient for a correct call. However, the behavioral ambiguity around detach/delete and the lack of any usage context keep it from being fully complete; the agent is left to infer 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?

Although schema coverage is 0%, the Args block documents all three parameters and adds critical semantics: clip_index and filter_index are explicitly 0-based, and filter_index is cross-referenced to filter_list. This fully compensates for the empty 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 one-line summary 'Detach an effect from a clip' names a specific verb and resource, and the filter_index reference ties it to the filter family, distinguishing it from transition/marker removal tools. The resource is slightly generic ('effect' rather than 'filter'), but the function name and parameter context resolve the ambiguity.

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

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

There is no explicit statement of when to prefer filter_remove over alternatives such as filter_add or filter_set_param. The only usage hint is '(see filter_list)' in the filter_index arg, which implies the agent should list filters first to resolve the index; this is implied rather than explicit.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does disclose key mutation behavior ('Update') and a useful conversion detail ('auto-converted to int/float if numeric'). However, it does not clarify what 'active filter' means, whether the filter must already exist, or what happens on invalid input or overwriting an existing value.

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

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

The description is short and front-loaded with the main action, followed by a compact, scannable argument list. Every sentence adds necessary information, and there is no redundant or filler content.

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

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

Given the fully documented parameters, the mutation warning, and the presence of an output schema, the description covers most operational needs. The remaining gap is the lack of guidance about filter 'active' state, error behavior, and distinction from clip_set_opacity, which keeps it from being fully complete.

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

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

Schema description coverage is 0%, yet the description fully compensates by explaining all five parameters, including indexing conventions ('0-based'), the meaning of track_id, and examples for parameter names. The value conversion note is especially valuable because the schema types value as a string even though it is auto-converted to numeric types.

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

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

The description states a specific verb and resource: 'Update a single parameter on an active filter.' This clearly distinguishes the tool from sibling filter operations like filter_add, filter_remove, and filter_list, while the phrase 'single parameter' narrows the scope precisely.

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 for when to use this tool versus alternatives. The sibling clip_set_opacity creates potential ambiguity because the description lists 'opacity' as an example parameter, yet it never explains when a user should set opacity via a filter parameter versus via clip_set_opacity. The intended usage is only implied by the first sentence.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic placement action and parameter meanings. It does not mention whether the operation is additive, whether duplicate positions are allowed, whether a timeline must be open, or any side effects.

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

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

The description is short and front-loaded, with a one-sentence purpose followed by a dense Args block. Every line contributes parameter details and there is no filler.

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

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

For a simple create-style tool with no annotations, the parameter documentation is sufficient and an output schema exists, so return values need not be described. However, missing usage boundaries and behavioral caveats prevent it from being fully complete for an agent choosing among guide/marker siblings.

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

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

Schema description coverage is 0%, yet the description covers all four parameters with useful semantics: 'position' is in seconds, 'label' is short, 'guide_type' lists the allowed values, and 'comment' is optional and longer. It adds meaning beyond the bare schema properties, though it could explain the practical distinction between guide_type 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 opens with a specific verb and resource: 'Place a navigation guide marker along the timeline.' This clearly defines the operation and distinguishes it from siblings like guide_update, guide_remove, guide_list, and marker_add by specifying a 'guide marker.'

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

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

No guidance is given about when to use guide_add versus related siblings such as guide_update, guide_remove, or marker_add. There are no prerequisites, conditions, or alternatives mentioned, so an agent must infer usage from the tool name and general wording.

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. The verb 'Get' implies a read-only, non-destructive operation, and 'single guide by ID' implies idempotent retrieval. However, the description does not disclose behavior for missing/invalid IDs or any special retrieval semantics, though these are less critical for a simple getter.

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 zero filler. Every word contributes to explaining the tool's purpose.

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

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

For a simple one-parameter getter with an output schema, the description and schema are sufficient for a correct call. It does not cover edge cases or sibling comparisons, but those are not essential for this tool's straightforward 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 compensate. It adds only 'by ID,' which restates the guide_id property name in the schema and provides little additional meaning about where the ID comes from or how it is used.

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

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

The description states a specific action ('Get') on a specific resource ('single guide') and specifies the selection method ('by ID'). It clearly distinguishes itself from siblings like guide_list, guide_add, guide_remove, and guide_update.

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 'single guide by ID' implies the intended use case: retrieving one specific guide when its ID is known. However, it does not explicitly mention alternatives such as guide_list for retrieving multiple guides, nor does it state when not to use 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?

With no annotations, the description carries the burden of conveying safety and side effects. 'Return' does indicate a read-only operation, but the description does not disclose ordering, empty-result behavior, or whether unsaved timeline changes are reflected. It is adequate but minimal.

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

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

The description is one short sentence containing only essential information. It is front-loaded with the action and resource, with 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?

Given the tool's very low complexity, no parameters, and an existing output schema, the description covers everything needed to invoke it correctly. The phrase 'all guide markers' clarifies scope, and the output schema handles return-value details.

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

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

The tool has zero parameters and the input schema is empty, so there is no parameter detail to add. The description correctly aligns with the schema's implicit meaning by indicating a single, unfiltered listing 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 states a specific verb ('Return') and a clear resource with scope ('all guide markers on the timeline'). It is immediately distinguishable from the sibling guide_get tool, which implies fetching a specific guide rather than listing all.

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 guide_get, guide_list, or marker_list. An agent must infer the appropriate choice from the tool name and sibling list rather than from explicit direction.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states the basic delete action but does not mention whether deletion is permanent, what happens if the guide_id does not exist, or any side effects.

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

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

The description is extremely concise and front-loaded, with a clear action sentence followed by a single parameter explanation. No unnecessary information is included.

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 single-parameter delete tool with an output schema, the description is largely complete for invocation. It is missing minor behavioral context such as idempotency and error handling, but those are not critical 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 schema has no property descriptions, so the description's 'Numeric guide identifier' provides the semantic role for guide_id. It is helpful but largely restates the schema type and title, adding little beyond identifying the parameter as the guide's ID.

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

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

The description clearly states the verb 'Delete' and the resource 'guide marker', making the tool's purpose immediately understandable. However, it does not explicitly differentiate from sibling remove tools such as marker_remove or filter_remove, aside from 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 about when to use this tool versus related alternatives like guide_update, guide_list, or marker_remove. It only states the action, 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?

With no annotations, the description carries the full burden of behavioral disclosure, but 'Update guide properties' only signals mutation. It doesn't say whether omitted properties are preserved, whether null values clear fields, whether it is reversible, or what side effects occur on the guide.

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

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

The description is short and has no filler, but it is under-specified rather than concisely informative. It is a single vague phrase that omits essential details, so brevity does not compensate for its lack of substance.

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

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

For a tool with five parameters, one required and no annotations, this description is far too thin. It doesn't state prerequisites, the exact set of updatable properties, or behavior on success/failure, even though an output schema is present.

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 parameter information at all. It doesn't identify guide_id as the required identifier, nor explain that label, comment, position, and guide_type are optional/nullable or what their update semantics are.

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

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

The description names a specific verb and resource: 'Update guide properties', which distinguishes it from siblings such as guide_add, guide_remove, guide_get, and guide_list. However, it doesn't enumerate which guide properties are modifiable or mention that an existing guide_id is required, so it stops short of a fully precise purpose.

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

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

No guidance is provided about when to use this tool instead of its alternatives. The only signal is the verb 'Update', which implies an existing guide, but the description never states that or warns against using it for creation/deletion.

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 says 'Add' and mentions the marker/guide distinction; it does not reveal side effects, reversibility, permissions, or how adding a timeline marker differs behaviorally from adding a clip marker. This is a significant transparency gap for a mutating tool.

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

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

The description is a single sentence with no filler and the key differentiator (time or clip, separate from guides) is front-loaded. It is concise, though perhaps too brief to carry full tool guidance.

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

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

Given the tool has six parameters and zero schema descriptions, the description is incomplete for correct invocation. An agent would not know what marker_type values are valid, how clip markers differ from timeline markers in terms of parameters, or what the output schema represents. The presence of an output schema does not compensate for missing parameter and behavior context.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It hints at a timeline/clip distinction that maps to position vs. track_id/clip_index, but it does not explain the role of label, comment, marker_type, or how the required position interplays with the optional 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 uses a specific verb ('Add') and resource ('timeline or clip marker'), and explicitly states that markers are separate from guides, distinguishing it from the sibling guide_add tool. An agent can immediately understand what this tool is for and what it is not.

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 'markers separate from guides' provides clear contextual guidance that this tool should be used for markers rather than guides, which is a relevant alternative in the sibling list. It does not explicitly name guide_add, but the distinction is enough to route the agent correctly.

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 behavioral burden. 'List all markers' clearly indicates a non-mutating, read-only operation and conveys that no filtering or pagination is applied. For a zero-parameter list operation, this is adequate.

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

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

The description is a single front-loaded sentence with no wasted words. It states the action and the object clearly.

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-parameter list tool with an output schema, 'List all markers' is complete enough. The main ambiguity is whether 'markers' refers to a specific timeline or project, but the sibling tool names and the operation itself make this reasonably clear.

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

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

The tool has no parameters and the schema covers 100% of them. The baseline for zero-parameter tools is 4, and the description does not need to add parameter-level detail.

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 ('List') and a clear resource ('all markers'), and the scope word 'all' distinguishes it from marker_add and marker_remove. It is immediately obvious what the tool does.

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 alternatives. The intended use is implied by the name and description, but no context or exclusions are stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it only states that the marker is removed. It does not disclose whether removal is permanent, whether it affects timeline state, whether it can be undone, or what happens if the ID is invalid.

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

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

The description is a single short sentence with no filler or repetition. The action and target are front-loaded, and the structure is appropriately sized for a simple one-parameter removal tool.

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

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

For a simple one-parameter removal tool, the description is minimally sufficient: an agent can infer the call shape from marker_id and the verb 'remove'. However, with no annotations or usage guidance, it leaves room for ambiguity about the context of markers and the operation's side effects.

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

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

Schema description coverage is 0%, but the phrase 'by ID' clarifies that marker_id is the selector used to identify the marker. This is minimal compensation for a single obvious parameter, though it adds little beyond the schema's marker_id property name and integer type.

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

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

The description 'Remove marker by ID' uses a specific verb and resource, clearly indicating the action and the key input. It doesn't explicitly contrast with sibling tools, but the target is unambiguous and distinct from marker_add and marker_list.

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

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

No guidance is given about when to use this tool versus alternatives, such as needing to look up the marker ID via marker_list first. There are no stated prerequisites, exclusions, or conditions that would help an agent decide between this and related marker 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?

There are no annotations, so the description carries the behavioral burden. 'Return' clearly signals a read-only operation with no mutation, and the metadata categories set expectations for the response. It could mention prerequisites like an open project, but for a no-argument getter this is adequate.

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

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

A single sentence with the verb and object front-loaded, followed by a compact list of returned fields. Every word carries information and there is no boilerplate.

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 parameters and an output schema present, the description only needs to say what the tool returns, which it does. Minor ambiguity about whether 'project' means the current active project is easily resolved from the sibling set, so nothing critical is missing.

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

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

The tool has zero parameters, so no parameter documentation is required in the description. The baseline of 4 applies because there is nothing for the schema or description to explain.

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

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

The description states a clear verb ('Return') and resource ('project metadata') and enumerates concrete outputs: FPS, resolution, track layout, bin clip count. It does not explicitly contrast with sibling getters like project_get_profile or timeline_get_info, though the combined field list implies a project-wide overview.

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 siblings such as project_get_profile, timeline_get_info, or bin_list_clips. The intended use is implied by 'project metadata' but there are no exclusions or alternative routing.

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

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

No annotations are provided, so the description carries the safety burden. 'Get' implies a non-mutating read operation and the parenthetical lists the returned fields, but the description does not state behavior around missing or unopened projects, errors, or side effects. This is acceptable but not richly transparent.

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 states the action, the target, and the key output dimensions efficiently.

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 parameters, an output schema available, and a simple read-only operation, the description covers all invocation-relevant information. The phrase 'current project's' provides enough disambiguation among the project_* siblings.

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

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

There are zero parameters, so parameter clarification is unnecessary; the baseline for 0 params is 4. The parenthetical adds useful context about the output content even though no parameter semantics are needed.

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

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

The description uses a specific verb ('Get') and resource ('current project's video profile'), and clarifies what the profile includes with 'resolution, FPS, aspect ratio.' This clearly distinguishes it from siblings like project_set_profile and project_list_profiles.

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 phrase 'current project's video profile' — an agent can infer it is for reading the active project's profile rather than listing or setting profiles. However, no explicit alternatives, when-to-use, or when-not-to-use guidance 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, so the description carries the full burden of behavioral disclosure. It indicates a read-style operation via 'get', but does not mention return shape, error behavior, side effects, or any other behavioral details. For an alias tool this is a modest 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?

One short, direct sentence that communicates both the alias relationship and the human-readable purpose. No filler or redundancy.

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

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

For a parameterless alias tool with an output schema, the description is largely complete: it names the sibling behavior and the intent. Additional detail about return formatting would be redundant given the output schema, though a little more behavioral context would help.

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 zero parameters and schema description coverage is 100%, so there is nothing for the description to add about parameter meaning. The baseline of 4 applies for a parameterless tool.

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

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

The description clearly states the tool gets available render presets and explicitly identifies itself as an alias for project_list_profiles. It names the specific resource and operation, though it relies on the sibling reference for full disambiguation.

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 alias relationship implies this tool is interchangeable with project_list_profiles, which gives some usage context. However, there is no explicit guidance on when to prefer this tool over alternatives like project_get_profile or export_list_presets.

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. 'Enumerate' strongly implies a read-only listing operation, and the examples give useful context about the kind of values returned. However, it does not explicitly state that the operation has no side effects, nor does it clarify whether 'available' is global or dependent on the current project 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 sentence that leads with the action and noun, then provides illustrative examples. There is no redundant information, and every word contributes to understanding the tool's purpose.

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

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

For a zero-parameter list operation with an output schema present, the description is complete. An agent can safely invoke the tool with no arguments and expect a list of available profile identifiers, as illustrated by the examples. Nothing critical is missing.

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

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

The tool has zero parameters, so the parameter baseline is 4. The description is not required to explain parameters, but the examples add helpful context about the kind of output values the tool returns, which is a small bonus.

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 action (Enumerate) and resource (all available video output profiles), with concrete examples (hd1080p30, 4k60, sd_pal). It effectively conveys what the tool returns, though it does not explicitly distinguish itself from similar sibling tools like project_get_render_profiles or project_get_profile.

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 'all available video output profiles' provides clear context for when to use the tool: when an agent needs to discover available output profiles. It does not explicitly mention alternatives or exclusions, but the intent is evident enough for a zero-parameter listing operation.

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

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

With no annotations, the description carries the behavioral burden. It discloses a non-obvious side effect: the project path is stored and later tools automatically target this project. It also clarifies profile override behavior. It does not mention overwrite behavior, but the core state change is covered.

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

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

Front-loaded purpose, one key behavioral effect, then a clean Args list. No filler. The repeated 'ignored when profile is set' is slightly repetitive but improves clarity.

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

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

The description, alongside the output schema, gives an agent all needed information: how to create, what the path means, what profile choices exist, and how parameters interact. Since an output schema exists, return-value detail is not required.

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

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

Schema coverage is 0%, so the description must document every argument, and it does: output_path format, profile enum values, and the priority rule that profile overrides width/height/fps. This fully compensates for the schema.

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

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

States the specific action 'Create a brand new Kdenlive project session', naming the resource and clarifying it is a new session, which distinguishes it from project_open and project_save.

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 'brand new' plus the explanation that the path becomes the target for subsequent tools gives clear context for when to use it. It does not explicitly name project_open for existing projects, but the new-vs-existing distinction is evident.

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 disclosing behavioral traits. 'Load an existing project into the session' implies a mutation of the current session state, but it does not disclose side effects such as whether unsaved changes are discarded, whether the current project is replaced, or whether any confirmation is required. Without such disclosure, an agent cannot anticipate the impact of this action.

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

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

The description is concise and well-structured: a one-sentence purpose statement followed by an Args section. It is front-loaded with the core action and resource, and the parameter documentation is inline. No unnecessary words. It could be slightly more structured (e.g., bullet points), but it is efficient and clear.

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

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

While an output schema exists (so return values are covered), the description is missing important contextual information for a project-loading operation. It does not mention what happens to the current project state, whether the load is destructive, or what prerequisites exist (e.g., must the project file be valid). Given the operation is a fundamental session change, this lack of behavioral context is a significant gap, especially compared to richer descriptions of sibling tools.

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

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

The input schema only provides the parameter name 'Project Path' with no description (schema coverage 0%). The description adds meaning by stating the parameter is 'Path to an existing project file' and clarifies the expected format (.kdenlive-cli.json). This goes beyond the bare schema, though it does not elaborate on path resolution, validation, or acceptable file extensions. Given the minimal schema, this is a modest but useful enrichment.

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 'Load' and the specific resource 'an existing .kdenlive-cli.json project' and the destination 'into the session'. This is specific and distinct from sibling operations like project_new (which creates a project) and project_save (which persists the current project). The phrase 'existing' implicitly differentiates it from project_new, and the file format adds precision.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for loading a previously saved project, or that project_new is for creating a blank project, or that project_save is for persisting changes. In a toolset with many project-related operations, this omission leaves the agent to infer usage context from the tool name alone.

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

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

With no annotations provided, the description must disclose behavior itself. It states the tool writes state to a file and defaults to the original path, but it does not mention overwrite behavior, file format, or potential side effects. This is a meaningful gap for a persistence operation that could overwrite existing project files.

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 with no filler. The core action is front-loaded, and the parameter explanation is minimal and directly useful. 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 tool is simple and has an output schema, so return values need not be explained. However, for a save operation, details like file format and overwrite semantics would materially affect correct invocation and error handling. The description is minimally viable but leaves these 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 only describes output_path as an optional string or null with no explanation. The description compensates by explaining that the path is optional and defaults to the original project path. It does not specify format or extension constraints, but for a single optional parameter this is adequate.

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-resource pair: 'Persist the current project state to a file.' This clearly distinguishes it from siblings like project_new, project_open, and export_xml, which either create/load projects or export in a different sense. The default-to-original-path detail further clarifies it is the save operation.

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

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

The description gives no guidance on when to use project_save versus alternatives such as export_xml or export_render. It does not state when saving is appropriate, whether a project must be open first, or when the default output path should be overridden. This leaves usage context to the agent's inference.

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

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

No annotations are present, so the description must carry the full behavioral burden. It does disclose one useful behavioral trait—that profile overrides width/height/fps if set—but omits side effects, persistence, reversibility, permissions, or whether at least one argument must be provided.

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?

Opens with a single-sentence purpose followed by a clean, scannable Args block. It is appropriately concise; the parameter names duplicate schema properties, but the added descriptions justify the repetition.

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

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

Covers all parameter meanings and includes an output schema, so return values do not need explanation. However, with zero required parameters and no annotations, it does not clarify whether at least one argument is needed or how profile changes propagate through the project, leaving moderate ambiguity.

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 compensates by listing all eight parameters with units and contextual meanings. It adds the preset enum for profile and the key relationship that profile overrides width/height/fps, which the schema alone does not convey.

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 action and resource: 'Set or update the project's video profile.' This clearly differentiates from sibling getters like project_get_profile and project_list_profiles, whose names and purposes are distinct.

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

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

Provides no guidance on when to use this tool instead of alternatives. It does not mention using project_list_profiles to enumerate available profiles or project_get_profile to inspect current settings, leaving selection entirely to inference.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Add job' without explaining side effects, whether rendering begins immediately, whether existing queue entries are affected, or what happens on failure. The mutating nature of the tool is implied but not detailed.

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

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

The description is a single front-loaded sentence with no filler or redundant wording. It is concise, though arguably too sparse for a four-parameter tool; that limitation is better attributed to completeness than to structure.

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

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

The tool has four parameters and no annotations, but the description only states the broad operation. Required parameter semantics, optional in/out point behavior, preset handling, and side effects are all missing, and the presence of an output schema does not compensate for that 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%, and the description adds no meaning for output_path, preset, in_point, or out_point. The agent must rely only on bare names and types, with no explanation of units, allowed values, or relationships between 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 uses a specific action verb ('Add') and a clear target resource ('render queue'), and it is not a tautology. It broadly differentiates this tool from queue-management siblings like render_queue_start and render_queue_list, though it does not explicitly name or contrast them.

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

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

The description provides no guidance on when to use this tool versus alternatives such as export_render or render_queue_start. Any usage inference must come from the tool name and sibling list rather than from the description itself.

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

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

No annotations are present, so the description carries the full burden. 'List render queue jobs' implies a read-only operation but does not disclose return format, ordering, state filtering, or effects. The output schema may cover structure, but behavior beyond listing is undocumented.

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 filler. It communicates the essential action in minimal space, which is appropriate for a zero-parameter list 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?

Given no parameters and the presence of an output schema, the description is functionally adequate. However, the total absence of usage guidance or behavioral notes leaves minor gaps, such as whether this lists all jobs or only pending/active ones, which matters among the render_queue_* siblings.

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

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

The tool has zero parameters, so the input schema is fully covered and no parameter explanations are required. The description appropriately adds no redundant 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 clear verb and resource ('List render queue jobs'), making the primary purpose immediately understandable. However, it does not differentiate this from sibling tools like render_queue_status, which also relates to the render queue.

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 render_queue_status or render_queue_start. An agent must infer the intended use from the name and sibling list, with no explicit 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 usefully discloses that rendering is sequential and uses melt, but it does not describe whether processing is asynchronous, what side effects occur, or how the operation can be monitored or stopped.

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

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

A single sentence with a useful parenthetical; the action is front-loaded and every element earns its place. There is no filler, repetition, or unnecessary elaboration.

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

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

For a parameterless trigger with an output schema, this is nearly complete. It gives enough to invoke the tool correctly, though mentioning that progress can be checked via render_queue_status would make it fully self-contained.

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 and schema coverage is 100%, so there is no parameter burden for the description to carry. The baseline for zero-parameter tools is 4, and the description appropriately adds no redundant parameter details.

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 ('Start processing') and resource ('render queue'), and adds implementation detail ('renders sequentially via melt'). This clearly identifies the action and differentiates it from sibling tools such as render_queue_stop and render_queue_add.

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

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

The intended use is implied—start rendering when the queue is populated—but the description does not explicitly state when to use it versus alternatives, nor does it mention prerequisites like a non-empty queue or how to monitor/stop rendering.

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 behavioral disclosure burden. 'Get' reasonably implies a read-only operation, but the description does not disclose what status information is returned, whether it includes progress or queued items, or any other behavioral details beyond the basic action.

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

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

The description is a single, focused sentence that directly communicates the tool's purpose. Every word earns its place, and there is no redundant or vague 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?

Given that the tool has no parameters and an output schema exists, the description is largely sufficient for an agent to invoke it correctly. The main missing element is guidance on how this differs from render_queue_list, but that is more of a usage-guideline gap than a completeness gap for the invocation itself.

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 and the input schema is empty, so there is no parameter semantics gap. The description does not need to explain parameters because there are none to explain.

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 ('Get') and the resource ('render queue status'), so an agent knows what it does. However, it does not explicitly distinguish itself from the sibling render_queue_list, which could be confused as an alternative way to inspect the queue.

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 render_queue_list, render_queue_start, or render_queue_stop. The description gives no context, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, the description carries the behavioral disclosure burden. It does add one useful detail beyond the name—'marks running as stopped'—suggesting a state transition rather than a hard cancel. Yet it does not explain effects on queued items, idempotency, or what happens when nothing is running.

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 one short, front-loaded sentence with a parenthetical clarification. Every word contributes meaning, and there is no redundancy.

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

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

For a zero-parameter command with an output schema, the description is largely complete. It could be improved by stating behavior when the queue is idle or how non-running items are affected, but the core call semantics are clear.

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

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

The tool has zero parameters and schema coverage is 100%, so the baseline is 4. The description appropriately adds no parameter details because none exist.

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 ('Stop') and resource ('render queue'), and clearly distinguishes the action from siblings like render_queue_start and render_queue_status. The parenthetical adds precision by specifying the state effect: running items are marked as stopped.

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: call this when a render queue is running and needs to be stopped. However, there is no explicit guidance on when not to use it or how it differs from render_queue_start/status, leaving the agent to infer context from the tool name.

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

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

There are no annotations, so the description must carry the behavioral load. 'List' clearly signals a non-mutating operation, and 'with descriptions' tells the agent what kind of content to expect. It does not detail ordering or formatting, but an output schema exists to cover return structure.

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 states the action, the object, and the key detail about output. Every word earns its place.

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

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

For a zero-parameter, read-only listing tool with an output schema, the description is fully sufficient. It communicates scope ('all') and content ('descriptions'), and no other selection or invocation criteria are needed.

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

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

The tool takes zero parameters (schema has no properties), so there is nothing for the description to explain about arguments. With no parameters, the baseline is 4; no parameter information is missing.

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 ('List') and a clear resource ('all undo/redo history entries'), and adds that entries come 'with descriptions.' This is unambiguous and separates the operation from action siblings like session_undo and session_redo, which perform state changes rather than inspect history.

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

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

No usage guidance is provided: the description does not say when to prefer this over session_undo, session_redo, session_undo_step, or session_redo_step, nor does it state any exclusion conditions. The intended use is only implied by the verb and resource.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but does not explain what happens when there is nothing to redo, whether the redo mutates session state, or any other side effects 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?

The description is a single sentence that immediately states the core action without wasted words. It is concise, though slightly under-specified in terms of prerequisites and failure modes.

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 state-changing command with no annotations, the description is thin. It does not address empty undo history behavior or distinguish itself from session_redo_step. The presence of an output schema covers return values, but the usage context remains incomplete.

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

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

The tool takes zero parameters and schema description coverage is effectively 100%, so the baseline is 4. There is no meaningful parameter information for the description to add.

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 ('Reapply') with a clear object ('the last undone operation'), so it states what the tool does and is not a tautology. However, it does not differentiate from the sibling 'session_redo_step', which appears to target a very similar operation.

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 siblings like session_undo_step or session_redo_step, and no prerequisites are stated (e.g., an undone operation must exist). The intended context is only implied by the phrase 'last undone operation.'

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 supplies the core behavior: redo exactly N steps. However, it does not mention side effects, limits on N, failure behavior, or relationship to the redo history, so transparency is only partial.

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

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

The description is compact and action-first, with no filler. The 'granular' parenthetical is the only extra qualifier and could be more precise, but the length is appropriate for a simple tool.

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

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

For a one-parameter operation the description is minimally adequate, and the presence of an output schema reduces the need to document return values. It remains incomplete because it gives no usage context or behavioral caveats beyond the basic operation.

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

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

Schema coverage is 0%, so the description must explain the parameter, and it does: 'N steps' directly maps to the steps integer. It does not add detail about valid ranges or default behavior, but the schema supplies the default of 1.

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

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

The description clearly states a specific verb ('redo') and resource ('N steps'), so an agent knows the operation. It does not explicitly name or contrast the sibling session_redo, so it misses full sibling differentiation that would justify 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?

No guidance is given for when to use this tool instead of session_redo, session_undo, or session_undo_step. The parenthetical 'granular' hints at step-by-step behavior but does not state a selection rule or exclusion condition.

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. The verb 'Inspect' clearly signals a read-only operation with no mutation side effects, and the listed state fields provide useful context beyond the tool name. It does not discuss failure modes, but none are strongly expected for a status inspection tool.

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

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

The description is a single front-loaded sentence that conveys purpose and output substance without filler. Every word earns its place, and the structure is easy to scan.

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

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

Given zero parameters and an existing output schema, the description is largely complete by listing the three state dimensions it inspects. The only notable gap is that it does not clarify the relationship or distinction from the sibling session_history tool, which could matter for tool selection.

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

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

This tool has zero parameters, so parameter semantics are essentially moot. The description adds no parameter-specific information, but none is needed; the baseline for a parameterless tool is 4.

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

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

The description uses a specific verb ('Inspect') with a clear resource ('session state') and enumerates three concrete aspects: project loaded, modified flag, history depth. This makes the tool's purpose immediately unambiguous and distinct from mutation-oriented siblings like session_undo and session_history.

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

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

No guidance is given about when to use this tool versus sibling tools such as session_history, session_undo_step, or session_redo_step. There are no exclusions or alternative recommendations, leaving the agent to infer appropriate usage from the tool name and description.

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

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

With no annotations, the description carries the burden. It discloses that the operation reverts a change and that history is limited to 50 entries, which is useful. But it omits what happens when the history is empty, whether redo is cleared, or whether the operation is destructive.

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

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

A single, efficient sentence that front-loads the verb and object, with a parenthetical adding the relevant limit. Every word earns its place.

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

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

For a no-argument mutation with an output schema, the description is nearly sufficient. It states the core operation and the 50-entry limit. Minor gaps: the relationship to session_redo/session_undo_step and empty-history behavior are implied but not stated.

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

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

There are zero parameters, so the baseline is 4. The schema fully documents the empty parameter set (100% coverage), and the description appropriately doesn't add redundant parameter details.

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 ('Revert the most recent state change') and the resource, and adds a history depth limit. However, it does not differentiate from the sibling session_undo_step, which likely performs a similar operation at a different granularity.

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

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

No guidance on when to use this tool versus alternatives like session_undo_step or session_redo. It also doesn't mention context such as whether a project must be open or how it interacts with the redo stack.

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

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

No annotations are provided, so the description must carry the full burden. It discloses only that the tool reverses N steps; it says nothing about limits, invalid N values, interactions with redo history, or what happens when N exceeds available history. This is a significant gap for a state-mutating tool.

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

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

Four words plus a parenthetical, all relevant and front-loaded. No filler or redundant phrasing.

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 and no usage comparison to closely related sibling undo/redo tools, the description does not provide enough context to select and invoke it correctly. The output schema may cover return values, but invocation context, constraints, and sibling differentiation are missing.

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

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

The single parameter 'steps' is undocumented in the schema (0% coverage), and the description maps it to 'N steps' in the operation, which is minimal but real added meaning. It does not state valid ranges, defaults beyond the schema's own default of 1, or behavior for zero or negative 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?

States a direct verb ('Undo'), a specific resource ('N steps'), and a qualifier ('granular') that implies per-step rather than whole-history undo. It is clear on its own, but it does not explicitly differentiate from sibling session_undo or session_redo_step.

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 this tool should be chosen over session_undo, session_redo_step, or session_history. The agent must infer the appropriate usage from the name and the one-word qualifier 'granular'.

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

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

With no annotations, the description carries the behavioral burden. It explains trim-in/trim-out semantics and the out_point default, which adds value. However, it does not disclose potential side effects such as overlapping behavior, whether existing clips are overwritten, track validity requirements, or failure modes.

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 main statement is one concise sentence, followed by a compact argument list. Every line adds information and there is no filler or redundant repetition of schema titles.

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

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

The description covers all parameters, the source of clip_id, and follow-up tool usage. It lacks explicit constraints around track existence, overlap policy, or timeline boundaries, but the presence of an output schema and the clear parameter explanations make it mostly complete for correct invocation.

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

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

Schema description coverage is 0%, so the Args section fully compensates. Every parameter is explained with units and meaning, clip_id sourcing is noted, and out_point's default to full bin duration is explicitly stated.

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 action: 'Place a bin clip onto a specific track at a given time position.' This clearly identifies the resource (bin clip, track, timeline), the operation (placement), and distinguishes it from sibling tools like timeline_move_clip or timeline_add_track.

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 useful routing context by stating clip_id comes from bin_list_clips and explicitly recommends timeline_trim_clip for post-placement adjustments. It does not enumerate when not to use this tool versus other timeline editing tools, but the intended use case is clear.

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

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

With no annotations provided, the description carries the full burden. It does disclose meaningful behavior: appending creates a new track, track_name auto-generates when omitted, and booleans set initial muted/hidden/locked states. However, it does not mention name-uniqueness constraints, what happens to existing tracks, or any error conditions.

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?

Leads with a clear one-sentence purpose followed by a compact, single-line-per-parameter argument list. The description is short, scannable, and contains no filler or repetition of the schema's default values.

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?

All five parameters are covered, the purpose is clear, and an output schema exists so the return value need not be described. The only minor gaps are edge cases like invalid track_type values or naming conflicts, which are not essential for a basic append 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 fully compensates. Every parameter is given practical meaning: track_type is restricted to 'video' or 'audio', track_name is optional and auto-generated, and mute/hide/locked are described by their start-state effects. This is far more valuable than 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?

States a specific verb ('Append'), a specific resource ('video or audio track'), and the destination ('to the timeline'). This clearly distinguishes it from sibling tools like timeline_add_clip, track_set_muted, and timeline_remove_track.

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

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

Provides no guidance on when to choose this tool over alternatives, no exclusions, and no context about prerequisites such as having a timeline open. An agent must infer usage purely from the generic 'Append a video or audio track' statement.

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. The verb 'Get' implies a read-only, side-effect-free operation, and the parenthetical 'max end time' adds meaningful behavioral detail beyond just restating the tool name. For a simple getter, this is sufficient 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 action, target, unit, and semantic definition with no 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?

This is a zero-parameter, read-only getter with an output schema available. The description explains exactly what the tool computes and its unit, so nothing is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parameters and an empty input schema, so the baseline is 4. The description adds no parameter-specific information, and none is needed since there is nothing to configure.

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-resource pair ('Get total timeline duration') and adds a precise semantic definition ('max end time') plus units ('in seconds'). This clearly distinguishes it from siblings like timeline_get_position and timeline_get_info without requiring schema inspection.

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

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

The description implies usage through its clear name and semantics, but it does not explicitly state when to choose this over timeline_get_position or timeline_get_info, nor does it mention exclusions. The guidance is adequate but left to inference.

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

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

With no annotations, the description carries the full burden, and 'Get ... info' clearly communicates a read-only operation with no mutation or destructive side effects. It also discloses the scope of data returned. It does not explicitly say 'does not modify the timeline,' but the verb choice and info framing make that safe behavior evident.

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 states the verb and resource, then a compact colon-led list enumerates all returned categories. There is no filler, repetition, or irrelevant 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?

For a zero-parameter info-getter with an output schema, the description fully covers what an agent needs to know: what the tool is for and what data it returns. The output schema handles the detailed return-value shape, and the listed categories match the complex scope of timeline state.

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 baseline is 4. There are no parameter semantics to document, and the description correctly avoids inventing any.

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 ('Get') and resource ('timeline info') and enumerates the distinct data groups (tracks+clips, duration, position, zoom, guides, markers, profile). This clearly distinguishes it from sibling tools like timeline_get_duration, timeline_get_position, and timeline_get_zoom by positioning it as the comprehensive aggregate.

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?

While it does not explicitly name alternatives or say 'use this when you need multiple values,' the word 'comprehensive' plus the explicit inclusion of duration, position, and zoom strongly signals this is the umbrella info tool versus the narrower single-purpose getters. The context is clear, though exclusions are 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?

With no annotations provided, the description carries the full burden. The verb "get" implies a read-only operation with no side effects, which is accurate. However, it does not disclose units, return format, failure conditions, or whether a project/timeline must be open, though the trivial nature of the operation lessens the impact of this omission.

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 five-word sentence with no filler. Every word earns its place, and the core operation is front-loaded.

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

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

For a parameterless getter with an output schema available, the description is nearly complete. It states what is retrieved, and the output schema covers return details. It could add context about prerequisites or units, but the low complexity makes the current description adequate.

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

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

The tool has zero parameters and an empty input schema, so there is nothing for the description to add. Baseline of 4 is appropriate for a parameterless tool.

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

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

The description uses a specific verb and resource: "Get current playhead position." This clearly identifies the operation and distinguishes it from siblings like timeline_seek (which moves the playhead) and timeline_get_duration (which reads a different timeline property).

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

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

The description gives no guidance on when to use this tool versus alternatives such as timeline_seek or timeline_get_info. No exclusions or conditions are provided, so the agent is left to infer usage from the name alone.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only restates what the name already implies and does not mention side effects, state requirements, or whether this operation is strictly non-mutating.

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

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

The description is a single focused sentence with no filler. It front-loads the essential action and is appropriately sized for a zero-parameter getter.

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

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

For a no-parameter getter with an output schema, the description is mostly complete: an agent can invoke it without ambiguity. It could be slightly richer by explicitly noting that it is a read-only operation or stating what zoom units are returned, but the output schema likely covers the return format.

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

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

The tool has zero parameters, so parameter semantics are not a concern. The 100% schema coverage of an empty schema fully documents the lack of inputs, and the description adds no necessary 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 clearly states the verb and resource: it gets the timeline zoom level. It is unambiguous, though it does not explicitly distinguish itself from timeline_set_zoom beyond what the names imply.

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 timeline_set_zoom. The read-only nature is implied by the word 'Get', but the description never states it or mentions any prerequisites.

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