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. 'Register' implies some state change or side effect, but the description does not disclose whether this mutates data, requires authentication, what the response looks like, or what side effects occur. For a mutation-style tool with zero annotation coverage, this is a significant gap.

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

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

The description is technically short at four words, but this is under-specification, not conciseness. For a tool with 5 parameters, 0% schema coverage, and no annotations, this brevity is a defect. There is no structure, no critical information front-loaded – nothing that earns the words' 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?

Completely inadequate for a tool of this complexity: 5 parameters, 2 required, an enum type, no output schema, and no annotations. An agent cannot determine what 'register' means operationally, what parameter formats are expected, what success/failure looks like, or how this differs from ingest_asset. Nothing an agent needs to call this correctly is provided.

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. With 5 parameters (asset_id, type, uri, color, duration), the description provides no information about any of them – not even which are required, what formats are expected, or what the type enum represents beyond the schema. The description adds zero value over the raw schema.

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

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

The description states a verb ('Register') and a resource ('source asset'), so there is a minimal verb+resource pairing. However, 'register' is vague and offers no differentiation from the sibling tool 'ingest_asset' – an agent cannot tell whether these are the same operation, complementary operations, or mutually exclusive alternatives.

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. With siblings like ingest_asset, add_track, and add_clip present, the description gives the agent no basis for choosing add_asset over its alternatives. No prerequisites, exclusions, or context are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals only the core effect ('add an audio clip') and implies mutation, but gives no context about side effects, prerequisites like an open timeline, parameter behavior, or what happens in the project state.

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

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

The description is a single sentence with no filler, front-loading the action and object type. It is efficient, though the extreme brevity borders on under-specification, which is the reason it isn't a 5.

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

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

Given six parameters, no output schema, and no annotations, a description that only says 'Add an audio clip (music bed / VO)' is far from sufficient. The agent lacks parameter definitions, defaults, workflow context, and any sense of how the clip integrates with the project, making correct invocation implausible.

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 none of the six parameters (asset, src_in, volume, src_out, track_id, timeline_in) are explained by the schema. The description only mentions 'audio clip' generically and provides no meaning or relationship to the parameters, leaving the agent unable to determine correct 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 states a specific verb ('Add') and resource ('audio clip'), with clarifying examples 'music bed / VO'. This narrows the purpose relative to generic sibling tools like add_clip or add_asset, though it does not explicitly draw that distinction.

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

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

There is no guidance on when to use this tool versus alternatives such as add_clip, add_asset, or add_track. No conditions, prerequisites, or exclusions are mentioned, leaving the agent to infer 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?

With no annotations, the description carries full responsibility for behavioral disclosure. It does mention that it 'returns a diff,' which is a useful behavioral note. However, it omits any indication of mutation side effects, reversibility, permissions, or impact on existing timeline data. The mention of 'diff' suggests non-destructive behavior but is not explicit.

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

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

The description is one short sentence, which is concise, but it is under-specified for a tool with eight parameters. It lacks structure, front-loading of key constraints, or any elaboration. The brevity is not appropriate given the tool's complexity; it sacrifices necessary detail for terseness.

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 eight parameters, no output schema, and no annotations. The description fails to explain parameter semantics, return format (beyond 'a diff'), or usage context. Given the complexity, this is severely incomplete; an agent cannot reliably know how to set src_in/src_out, speed, or rationale without further information.

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

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

Schema description coverage is 0%, and the description provides no parameter explanations. The schema lists eight parameters (asset, speed, src_in, src_out, volume, track_id, rationale, timeline_in) but none are described in either schema or text. The description does not clarify what 'slice' refers to or how parameters like src_in/src_out map to it, leaving the agent to guess.

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

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

The description states the action ('Place'), the resource ('a slice of an asset'), and the target ('on a track'), and mentions it returns a diff. This distinguishes it from siblings like add_asset (whole asset) and add_track (track creation), though 'slice' could be more explicit about what constitutes a 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?

No guidance is given on when to use this tool versus alternatives. It does not mention any prerequisites, when it should be preferred over add_asset or trim, or what scenarios are inappropriate. The description is purely a statement of function without 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. It indicates the text is burned-in (a visual overlay) but does not disclose whether this mutates the timeline, whether existing text layers are affected, what track requirements exist, or how rendering/output is impacted. For a mutating tool this is a notable gap.

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

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

The description is a single efficient sentence with no filler, and it fronts the core action and object. It is appropriately minimal in wording, though the brevity comes at the cost of substantive detail that other dimensions require.

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

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

For a mutation-style tool with no annotations, no output schema, and fully undocumented parameters, the description is incomplete. An agent cannot confidently determine required inputs, preconditions, or behavioral side effects from this definition alone.

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

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

Schema description coverage is 0%, and the description adds essentially no parameter-level meaning. It does not explain what track_id, timeline_in, timeline_out, or font_size represent, nor how they interact. Five parameters remain effectively undocumented, and the one-word gloss 'caption/title' does not compensate.

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 identifies the resource ('text layer') with a clarifying qualifier ('burned-in caption/title'), making the tool's function understandable at a glance. It does not explicitly distinguish it from siblings like generate_captions or add_clip, so it misses the top score.

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

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

No guidance is given about when to use this tool versus alternatives such as generate_captions or add_clip. The agent must infer the intended use case from the name and a one-line description, with 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?

There are no annotations, so the description must carry the full burden of behavioral disclosure. It only says 'Add a track,' with no mention of side effects, scope, prerequisites, return behavior, or consequences of the operation.

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

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

The description is short but under-specified rather than appropriately concise. It does not earn its place by adding value beyond the tool name, and it provides no structured information that helps with invocation.

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

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

With no annotations, no output schema, and a bare tautological description, an agent has almost no context for calling this tool correctly. The definition is incomplete for even basic selection and invocation.

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

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

Schema description coverage is 0% and the description adds no meaning for track_id or kind. The enum in the schema gives option names, but the description does not explain how the parameters relate to the action or what values mean in practice.

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 is a near-verbatim restatement of the tool name: 'Add a track.' It names a generic verb and object but does not explain what a track is in this context or how it differs from sibling tools like add_asset, add_clip, or add_audio.

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

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

No guidance is given about when to use this tool versus the many alternatives. The only implicit signal is the name itself, which is insufficient to route an agent to the correct operation among more than 30 siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention that this is a mutating operation, how it affects existing transitions or clip edges, whether it is idempotent, or what side effects may occur.

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 redundant words. Every part contributes to stating the core operation, which is ideal for a tool with only three parameters.

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

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

For a mutating tool with no annotationsantations and no output schema, the description is too sparse to fully inform an agent. It omits parameter semantics, side effects, and return behavior, leaving critical operational context to inference.

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 missing parameter documentation. It partially maps 'fade in/out' to the kind parameter and 'clip edge' to clip_id, but it says nothing about duration, its units, defaults, or how kind and duration interact.

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: 'Add a fade in/out to a clip edge.' This clearly identifies the tool's function and differentiates it from siblings like add_clip, trim, or set_volume, which do not describe transition/fade operations.

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

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

No guidance is given about when to use this tool versus alternatives, prerequisites, or exclusions. The description only implies a use case for adding fades; it does not help an agent decide between this and related editing tools like set_volume or trim.

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 doesn't disclose whether this is a read-only or mutating operation, what side effects occur (e.g., modifies project state), or if it requires existing assets. For a tool with no annotations, this is a significant gap.

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

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

The description is a single clear sentence, which is appropriately concise. No wasted words, but it could be more informative without being verbose.

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

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

Given the complexity of an 'edit plan' tool, the description is incomplete. It lacks information about the plan's expected structure, any dependencies (like a loaded project), and what happens after assembly (e.g., does it render? update the timeline?). The lack of annotations and output schema increases the need for a richer description, which is absent.

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

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

Schema coverage is 0% and the schema only defines 'plan_json' as a string with no format details. The description says 'JSON string' which adds some context, but it doesn't explain the expected structure of the plan (e.g., keys, formats) or whether it's a path or inline JSON. The description adds minimal value beyond the schema.

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

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

The description states a specific verb ('Assemble') and resource ('cut from a structured edit plan'), which clearly differentiates it from siblings like 'render' or 'trim'. It is more specific than a tautology and gives enough to understand the primary function, though it could be more precise about the output.

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

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

No guidance on when to use this tool versus alternatives like 'build_narrative' or 'render'. It doesn't mention prerequisites (e.g., must have a project loaded) or the context in which this is the right choice. The agent must infer usage from the name and description alone.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It reveals that the action is automatic and voice-triggered, but does not state whether tracks are modified destructively, how duck_level is applied, whether it affects other tracks, or any side effects. Missing critical behavioral context for an audio-mutating operation.

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

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

The description is a single concise sentence that front-loads the core behavior. No filler, but it is under-specified for a tool that needs more explanation.

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

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

For a 3-parameter mutation tool with no annotations and no output schema, this description is far too thin. It does not explain what 'duck' means in practice, what duck_level does, whether the operation is reversible, what the expected result is, or which sibling tools it complements. An agent cannot call it correctly with confidence.

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

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

Schema description coverage is 0% and the description does not name or explain any parameter. It only hints that one track is voice and another is music, which loosely maps to voice_track_id and music_track_id, but it never defines duck_level or explains the relationship between parameters. The description fails to compensate for the schema's total lack of parameter documentation.

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 ('duck') and resource ('music volume'), and adds the condition 'when voice is present', which distinguishes it from a plain volume-set tool like set_volume. It doesn't explicitly name the distinction, but the purpose is immediately understandable.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies a use case (duck under voice), but it doesn't mention when not to use it, prerequisites, or that set_volume might be a manual alternative. Only implied usage, no 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 and no output schema, the description carries the full burden of behavioral disclosure, but it only says an index is built. It doesn't disclose whether an existing index is overwritten, what side effects occur, whether project_id/index_dir are needed despite being optional, or what the tool returns.

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

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

The description is a single concise sentence with no filler or repetition. It front-loads the core action and resource, though the brevity does sacrifice behavioral and usage detail that would make it more helpful.

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

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

For a tool with no annotations, no output schema, and undocummented optional parameters, the description is too thin. It explains the high-level action but omits prerequisites, side effects, return information, and the role of the two parameters, leaving the agent to guess operational details.

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

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

Schema description coverage is 0%, and the description does not explain either parameter (index_dir or project_id). The phrase 'from all ingested assets' doesn't map to parameter meaning, so an agent has no help understanding required or optional parameter 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?

The description states a specific verb ('Build'), a specific resource ('cross-asset narrative index'), and the scope ('from all ingested assets'). This is clear and distinguishes it from read/search-style siblings, though it does not explicitly name an alternative such as search_index.

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 'from all ingested assets' implies the tool should be used after assets have been ingested, providing implicit usage context. However, it gives no explicit guidance on when to choose this over sibling tools like ingest_asset, search_index, or assemble_from_plan, and no exclusions are stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to state whether the snapshot is a read-only operation or creates a persistent save point, whether it affects other state, or what the response contains. The lack of any behavioral detail is a significant gap.

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

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

The description is very short and front-loaded, but it is under-specified rather than concise. It fails to convey essential information, so the brevity is a detriment rather than an asset. There is no wasted text, but the content is insufficient.

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

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

For such a simple tool with many siblings and no annotations or output schema, the description is completely inadequate. It does not explain the purpose, effect, or when to use it, leaving the agent unable to decide if this is the right tool or how 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?

The input schema has one optional parameter 'label' with 0% description coverage, and the description does not clarify what 'label' represents or how it is used. The agent has to guess whether the label is a name for the checkpoint, a tag, or something else, with no help from the tool description.

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

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

The description 'Snapshot current state' is a vague and tautological restatement of the tool name 'checkpoint' with no clear verb, resource, or scope. It does not distinguish this from the many sibling tools, leaving the agent unsure of what state is captured and why.

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 like 'save_project', 'undo', or 'load_project'. There is no context, exclusions, or mention of prerequisites, making the tool's role in the workflow unclear.

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 only says 'Start,' without revealing whether the project is persisted, whether an existing id is overwritten, what defaults are applied, or what side effects occur. For a creation tool, these are central behavioral details.

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

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

The description is a single sentence and is front-loaded with the action and resource, which is structurally concise. However, it is under-specified rather than information-dense; it reads more like a label than a functional specification.

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

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

For a setup tool with five parameters, no output schema, and no annotations, one sentence is inadequate. The description does not explain the required id, the meaning of the optional parameters, default behavior, or how this tool fits into the broader Timeline-as-Data workflow.

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

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

Schema description coverage is 0% and the description mentions none of the five parameters. An agent cannot infer that id is a required identifier, what fps/width/height control, or how prompt is used. The description adds no semantic value for 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 states a concrete verb ('Start') and a specific resource ('new Timeline-as-Data project'), making the core purpose clear. The word 'new' helps distinguish it from load_project/save_project, though it does not explicitly name or contrast those siblings.

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

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

No guidance is given about when to use this tool versus alternatives like load_project or save_project. There is no mention of prerequisites, project lifecycle, or conditions that would make this tool the right choice. The only usage signal is the word 'new,' which 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool exports the project, implying a file-write operation, but does not disclose side effects such as whether an existing file is overwritten, whether permissions are required, or whether the operation is reversible. This is a significant gap for a tool that creates external artifacts.

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 consists of a single, front-loaded sentence with no filler words. It communicates the action, the subject, and the output format efficiently. Every word contributes to the tool's purpose, making it highly concise and well-structured.

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

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

For a simple export operation with one parameter and no output schema, the description covers the core functionality. However, it omits details like file-overwrite behavior, path requirements, and error outcomes. Given the lack of annotations and the need to fully inform an agent, the description falls short of being complete, though it is adequate for a trivial tool.

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

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

Schema description coverage is 0%, so the description must compensate. While the tool name and description indirectly imply that output_path is the file path for the .otio output, the description does not explicitly state what the parameter represents. The meaning is inferable, but the description does not add explicit semantic value beyond the schema's type declaration.

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 ('Export'), a resource ('the project'), and the target format (OpenTimelineIO .otio). This clearly distinguishes it from sibling tools like import_otio (which handles the opposite direction) and save_project (which likely saves in a native format). Even without opening the schema, an agent knows exactly what this tool does and how it differs from related operations.

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

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

The description implies usage when an OTIO file needs to be produced, but it does not explicitly mention alternative tools or conditions for choosing this over save_project or export-related siblings. The context is clear enough to infer the use case, but there is no direct guidance on when not to use it or which tool to prefer in overlapping 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 full burden of behavioral disclosure. It only says 'generate captions' without explaining side effects, return format, or whether it modifies anything. There is no information about what happens to the transcript or how the captions are delivered.

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

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

The description is a single, concise sentence with no wasted words. The purpose is front-loaded. However, it is under-specified for the tool's complexity, but that's more a completeness issue than conciseness. Structure is efficient.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain what the parameters do, what the output looks like, or how to use the tool effectively. An agent would have to guess essential details.

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

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

Schema description coverage is 0%, so the schema provides no explanations. The description does not mention any parameters, leaving the agent to infer from names like 'style', 'track_id', and 'index_dir'. 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?

The description states a clear action ('Generate captions from the transcript') with a verb and resource, but it is vague about what 'transcript' refers to and what the captions are for. It doesn't explicitly distinguish from siblings because no similar caption tool exists, but it could be more specific about the context (e.g., which track's transcript).

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

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

No guidance is provided about when to use this tool versus alternatives. There are no prerequisites, conditions, or exclusions mentioned. The description is a single sentence with no 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 side effects or behavioral traits, but it only says 'import' into the current project. It does not state whether this replaces, appends, or modifies existing timeline data, what permissions are needed, or what happens to the project state.

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

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

The description is a single, front-loaded sentence with no redundant words. It could carry more useful detail, but as written it is concise and readable.

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-like import tool with no annotations and no output schema, this description is incomplete. It does not mention side effects, return values, or the relationship between the imported file and the current project, leaving an agent without enough context to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must clarify the parameter. It adds that otio_path refers to an OpenTimelineIO file, but it does not explain path format, file extension, supported sources, or any constraints beyond that.

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

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

The description clearly states the action ('Import'), the input type ('OpenTimelineIO file'), and the destination ('current project'). It is specific and distinct from siblings like export_otio, though it does not explicitly differentiate itself from ingest_asset or load_project.

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

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

The description gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It only implies usage when one wants to import an OpenTimelineIO file, but that is not enough to help an agent choose among the many sibling tools.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It does disclose a sequence of operations (detect scenes, transcribe, analyze, index), but it does not explain side effects, whether the operation is destructive, whether it requires an opened project, or what state changes occur in the asset database.

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 tight sentence with the main verb and resource front-loaded, followed by a concise list of processing steps. It is efficient and scannable, though it omits contextual details that would not cost much extra space.

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 multi-stage ingestion tool with no annotations, no output schema, and no parameter documentation, the description is too thin. An agent cannot tell whether ingestion is synchronous, how long it may run, what it returns, whether it mutates the project, or how the three parameters interact.

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

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

Schema description coverage is 0% and the description does not mention uri, asset_id, or index_dir. While 'media file' hints at uri and the verb 'index' hints at index_dir, the mapping between parameters and their roles is left mostly to inference.

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

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

The description names a specific verb ('Ingest') and resource ('a media file'), and enumerates processing stages: detect scenes, transcribe, analyze, index. This is clear, but it does not explicitly distinguish ingest_asset from siblings like add_asset, so it stops 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?

There is no guidance about when to use this tool versus alternatives such as add_asset, add_track, or import_otio. The description implies a general ingest workflow but provides no context for when it is appropriate, what prerequisites exist, or when another tool should be chosen.

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 only says 'Load a project from JSON' — it does not mention side effects (e.g., overwriting current project), error behavior, file-format assumptions, or whether it is read-only. For a potentially mutating operation, this is a significant gap.

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

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

The description is a single, efficient sentence with no wasted words. It is front-loaded and clear. It could be considered under-specified, but as conciseness, it earns a high score because every word contributes.

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

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

For a simple one-parameter tool, the description is minimal but does not provide enough context: no output information, no side-effect expectations, no relationship to siblings. Given that there is no output schema and no annotations, the description is inadequate for an agent to confidently invoke it without guessing.

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

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

Schema description coverage is 0%, and the description does not elaborate on the 'path' parameter. While 'path' intuitively points to a file location, there is no confirmation of format, absolute/relative path expectations, or required file structure. The description adds no meaning beyond the schema itself.

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 ('Load') and resource ('a project') with the medium ('from JSON'). It clearly conveys the action and object. However, it does not explicitly distinguish itself from sibling tools like 'read' or 'import_otio' — though the JSON constraint gives some 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 on when to use this tool versus alternatives like 'create_project' or 'save_project', nor any prerequisites or context. The description merely states the action without saying when it is appropriate.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states 'Create a short clip', implying a mutation, but gives no details on side effects, whether it modifies an existing project, whether it exports files, or what the return value is. The agent is left guessing about the tool's impact and requirements.

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

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

The description is a single sentence with no filler. It is front-loaded with the core action. However, it is so brief that it sacrifices necessary detail, so it is concise but under-specified.

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

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

For a tool with 3 parameters, no output schema, and no annotations, the description is grossly incomplete. It fails to explain what source material is, how topic is used, what duration does, and what index_dir refers to. An agent cannot call this tool correctly without external knowledge.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only mentions 'matching a topic', which partially hints at the topic parameter, but it does not describe duration or index_dir at all. The agent has no idea what these parameters mean or how they affect the output.

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 (Create), resource (short clip), and context (from source material matching a topic). It is specific enough to distinguish from siblings like reframe_to or sync_cuts_to_beat, which focus on different operations. However, it does not clarify what 'short' means (duration? format?) or how topic is matched, so it is not maximally precise.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any conditions, exclusions, or related tools. An agent has to infer that it is for automated short creation, but there is no explicit indication of when it is appropriate.

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

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

Annotations are absent, so the description carries the full burden. It states only 'Move a clip on its track,' implying a side effect but does not disclose what happens to the previous position, whether moving causes collisions, or what the operation actually changes.

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

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

The description is six words and front-loads the verb. It is efficient with no filler, although its brevity borders on under-specification in other dimensions.

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 no annotations, no output schema, and no parameter descriptions, this definition does not give an agent enough to invoke it correctly (notably the meaning and units of timeline_in). The tool itself is simple, so the gap is meaningful but not catastrophic.

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

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

Schema description coverage is 0%, and the description does not compensate at all: it never mentions clip_id, timeline_in, what timeline_in represents (e.g., seconds, offset, target in-point), or any relationship between the two 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 ('move') and resource ('clip'), and scopes it to 'its track.' It is clear enough that this is a timeline move operation and none of the sibling tools shares exactly this purpose, though it does not explicitly contrast itself with siblings.

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

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

No guidance is given about when to use this tool instead of other timeline-editing siblings such as trim, add_clip, or set_speed. It does not mention any exclusions, prerequisites, or alternative tool references.

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

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

Annotations are absent, so the description must carry the full burden. It only says 'deterministic QC', which is opaque. It does not disclose what checks are performed, whether the file is modified, what 'deterministic' implies, or potential side effects. This is inadequate for an agent to predict tool behavior.

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

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

The description is extremely short (one sentence), which is concise, but it is under-specified. It front-loads the verb and noun, but the brevity sacrifices essential meaning. More sentences are needed to express purpose and usage 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?

Given the tool's complexity (unknown) and the absence of output schema, the description is grossly incomplete. An agent cannot determine what inputs must satisfy, what the output is, or what side effects occur. The sibling context suggests a video editing pipeline, but nothing here clarifies the role of QC.

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

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

Schema coverage is 0%, and the description adds no parameter information. With two parameters ('file' and 'expected_duration'), the agent knows the schema only as raw types (string, number) and lacks any semantic meaning for 'expected_duration' or the format of 'file'. The description must compensate but does not.

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 'Run deterministic QC on a rendered file' has a verb ('run') and a resource ('rendered file'), but 'deterministic QC' is vague, and it does not distinguish from siblings like 'read', 'render', or 'vlm_review'. The resource type is clear, but the specific purpose is underspecified.

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. Among siblings like 'render' and 'vlm_review', no conditions or exclusions are given. An agent cannot infer the intended context.

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

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

With no annotations provided, the description carries the full burden. The verb 'Read' and the phrase 'the agent inspects' clearly signal this is a non-destructive inspection operation, which covers the core behavioral safety trait. However, it does not describe what happens with the read output or whether any state changes occur per zoom level, though for a read tool the most important behavior is embodied in the verb itself.

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. It packs the verb, resource, and parameter relationship in the main clause, with a parenthetical that immediately communicates the use case. Every word adds value; there is no room for trimming.

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 low-complexity tool with one optional parameter, but the description still leaves key gaps. It does not state what output is returned (and there is no output schema), nor what each zoom level actually offers. An agent would need extra context to know exactly what happens when it calls this tool. The description, while simple, is not fully complete without those 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 only parameter 'zoom' has an enum but no schema descriptions, so the description must compensate. The description correctly ties the parameter to the notion of viewing the timeline at a zoom level, which adds meaning beyond the mere enum. However, it does not explain what each enum value (summary, outline, detail) semantically maps to, so the agent still lacks full parameter-level guidance.

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

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

The description clearly identifies a specific verb ('Read') and resource ('the timeline') with a scope qualifier ('at a zoom level'). The parenthetical 'the agent inspects its work' adds contextual purpose, distinguishing this from editing or creation siblings like add_clip or trim. It is not a perfect 5 because it does not explicitly name a sibling alternative, but the read-only verb is enough for agents to reliably distinguish it.

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

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

No explicit guidance is given about when to or when not to use the tool. The phrase 'the agent inspects its work' implies a checking or review use case, but there is no mention of alternatives like qc, vlm_review, or render, nor any exclusion criteria. This leaves the agent to infer when this tool is the right one compared to dozens of other timeline-related operations.

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

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

With no annotations present, the description must carry the behavioral burden, but it only states the action. It does not disclose whether the original asset is modified or a new asset is produced, whether rendering is triggered, or whether the operation is destructive/reversible.

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

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

The description is a single, front-loaded sentence with no filler. It loses a point only because its brevity contributes to ambiguity about what 'reframe' entails.

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 transformation tool with no annotations and no output schema, this is too thin. It omits the meaning of focus, whether target_aspect is required (it is not marked required in the schema), and what the tool returns or produces.

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 no meaning beyond the schema: 'video asset' maps to asset_id and 'different aspect ratio' maps to target_aspect, but focus is left unexplained. With 0% schema description coverage, the description should compensate by explaining how focus determines the reframe, and it does not.

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

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

The description names a concrete operation ('reframe'), a specific resource ('video asset'), and the intended outcome ('different aspect ratio'), which is enough to distinguish it from siblings like trim or make_short. It is clear but does not explicitly differentiate itself from related tools or clarify whether 'reframe' means cropping, scaling, or padding.

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 instead of alternatives such as make_short, render, or trim. The phrase 'for a different aspect ratio' implies the use case, but there are no conditions, exclusions, or sibling references.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It only states the primary action but does not mention whether the operation is destructive, whether it ripples subsequent clips, whether it works on all clip types, or any side effects. This is a significant 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, clear, front-loaded sentence with no redundant phrasing. It is appropriately concise, though it could add a bit more detail without becoming verbose.

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

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

For a tool with no annotations and no output schema, the description must carry the full burden of contextual completeness. It lacks critical information such as the effect on clip layout, reversibility, and the minimum required parameters. This is inadequate for safe autonomous invocation.

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

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

The schema has 0% description coverage, so the tool description must compensate by explaining the parameters. The description mentions 'track' but does not clarify that track_id is the identifier or explain what min_silence controls (e.g., the threshold in seconds). An agent would have to guess the semantics of min_silence from its name alone.

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

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

The description states a specific action ('Remove silent portions') on a specific resource ('clips on a track'), which distinguishes it from generic tools like trim or ripple_delete. However, it does not explicitly differentiate it from sibling tools that also operate on clips, so it falls 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 usage context: use this when you want to automatically remove silences from a track. It does not specify when NOT to use it or mention alternatives like manual trimming or ripple_delete, so the agent must infer the appropriate scenario.

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 does mention that rendering is deterministic and that QC is optional, which adds some context, but it omits important behavior such as whether a file is written, whether a project must be loaded, and what happens to existing outputs. This is a significant gap for a tool with no annotation support.

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 front-loads the main action and avoids filler. It is appropriately short, though the parenthetical 'deterministic' could have been expanded into a more useful behavioral note.

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

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

Given the existence of several render-related siblings, no annotations, and no output schema, the description leaves critical gaps: it does not explain the output parameter, dry-run semantics, or how this render differs from render_farm/render_proxy. An agent would likely need external knowledge to use the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It only hints at run_qc_after via 'optionally QC it'; output and dry_run remain unexplained. The description does not add enough meaning to help an agent fill parameters correctly.

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

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

The description uses a specific verb and resource: 'Compile the timeline to video', which clearly states the core operation. It also adds a useful distinguishing trait ('deterministic') and mentions optional QC. However, it does not explicitly differentiate from sibling tools like render_proxy or render_farm, so it is clear but not fully differentiated.

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

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

The description gives no guidance on when to choose this tool over alternatives such as render_proxy, render_farm, or render_farm_dry_run. It also does not clarify when dry_run or run_qc_after should be used.

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

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

No annotations are provided, so the description bears the full burden of disclosing behavior. It only paraphrases the tool name and adds 'distributed', which is already implied by 'render_farm'. It does not mention whether rendering is asynchronous, whether results are returned directly, what happens on failure, or what output means in this 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 one-sentence description is concise, but it is under-specified rather than appropriately sized. It provides almost no information beyond the tool name and omits critical context about parameters and behavior.

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

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

Given the lack of annotations, output schema, and parameter documentation, the description leaves an agent with insufficient information to call the tool correctly. It does not explain what 'output' should contain, what 'n_workers' does, what a render job entails, or what the tool returns.

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

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

Schema description coverage is 0%, and the description does not mention either parameter. The schema reveals only that 'output' is a required string and 'n_workers' is an optional integer, but neither the meaning of 'output' as a path/format/ID nor the role of 'n_workers' is explained. The description completely fails to compensate for the schema gap.

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

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

The description clearly states the action ('Render') and the specific resource ('the distributed render farm'), which distinguishes it at a basic level from sibling tools like render_proxy and render_farm_dry_run. However, it does not explicitly contrast it with the plain 'render' sibling, so some ambiguity remains.

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

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

There is no guidance about when to use this tool versus alternatives such as 'render', 'render_proxy', or 'render_farm_dry_run'. The description gives no context about choice criteria, prerequisites, or conditions that would make this tool preferable.

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 states that it does not render, which implies non-destructiveness, but it does not explicitly confirm that no files are changed or that it is safe to run multiple times. Additional details about side effects or return format would improve transparency.

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

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

The description is a single, concise sentence with no filler. It front-loads the action ('Show') and immediately clarifies the key distinction ('without rendering'), making it efficient and easy to parse.

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

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

Given the simplicity (no params, no output schema, no nested objects), the description adequately covers what the tool does. It might benefit from specifying what output the user can expect (e.g., a report or list), but it is not essential for a dry-run tool of this 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 tool has zero parameters, so the schema is trivially complete. The description does not need to explain parameters. Baseline for 0 params is 4, and the description adds no meaningful parameter info, which is appropriate.

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 'Show' and the resource 'what the render farm would do', explicitly differentiating from the sibling render_farm by adding 'without rendering'. This makes the tool's purpose unambiguous and distinguishes it from its closest alternative.

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

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

The description implies this is a preview/simulation tool (by 'without rendering') but does not explicitly state when to use it over render_farm, nor does it mention any conditions or exclusions. The guidance is implicit 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?

No annotations are provided, so the description alone must communicate behavior. It states that the tool produces a 'fast low-resolution proxy', but it does not disclose what happens to the original, what the proxy is used for, whether it is a read-only operation or if it modifies project state, or what the output format is. For a rendering tool, this lacks necessary context about side effects and constraints.

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

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

The description is a single, concise sentence that is easy to parse. It front-loads the essential action and purpose. However, its brevity comes at the expense of critical details, but for the length it has, it is well-structured and not verbose.

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

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

Given the tool's complexity (3 parameters, no schema descriptions, no annotations), the description is far from complete. It does not explain a critical detail: the meaning of the parameters, especially 'output'. It also does not clarify the relationship to sibling tools like 'render' or 'render_farm', leaving the agent without enough information to call it correctly.

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

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

Schema description coverage is 0%, meaning the schema provides no descriptions for the parameters. The tool description does not explain the meaning of 'width', 'height', or 'output'. For instance, does 'output' specify a file path or a format? Are width and height required? This is a severe gap; the description must compensate for the schema's lack of detail but does not.

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 ('render') and resource ('low-resolution proxy for review'), but it does not distinguish this from the sibling 'render' tool. Both tools appear to render, and without a clear differentiation, an agent may struggle to choose the correct one. The phrase 'fast low-resolution proxy' suggests a specific use case, but it is not explicit about why this tool exists versus 'render'.

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

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

There is no guidance on when to use this tool versus alternatives like 'render' or 'render_farm'. The description implies it is for quick previews ('fast low-resolution proxy for review'), but it does not state when to prefer this over 'render' or 'render_farm'. This is a critical gap given the sibling tool list includes multiple rendering options.

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 disclosing behavior. It does disclose that the tool is destructive and that it closes the resulting gap, but it does not say whether media is removed from disk or only the timeline, or whether the operation is reversible.

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

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

The description is a single seven-word sentence with no filler or redundant content. It states the action and the key side effect with maximum economy.

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 this is a one-parameter destructive tool with no output schema and no annotations, the description covers the core invocation details: what action is performed, what resource is affected, and what side effect results. It is sufficient for an agent to call the tool correctly, though it could add irreversibility context.

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

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

Schema description coverage is 0%, and the description adds no detail about the required clip_id parameter beyond its name. The role of clip_id is inferable from the tool's purpose, but the description itself does not compensate for the missing schema documentation.

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-object pair, 'Delete a clip', and adds the unique ripple behavior, 'close the gap'. This is enough to distinguish it from all sibling tools, none of which perform a plain clip deletion.

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 when-to-use guidance, no exclusion criteria, and names no alternatives. An agent cannot tell from the description when to prefer this over trim, split, or remove_silences.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. The description only restates the purpose without revealing any side effects, duration, project mutation, or dependencies. An agent cannot infer whether this tool modifies the current project, requires a loaded project, or returns a rendered output.

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

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

The description is a single sentence, which is concise, but it is under-specified rather than efficiently informative. It lacks structure, front-loading of critical information, and contains no additional useful details beyond the bare 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?

With 5 parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain parameter formats, expected input types, return values, side effects, or how this tool integrates with the rest of the workflow. An agent would be unable to call this tool correctly without additional information.

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

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

Schema description coverage is 0%, so the description must explain parameters, but it mentions none. It does not describe 'brief', 'style', 'index_dir', 'max_iterations', or 'target_duration'. The only hint is 'from a brief' which loosely relates to the required 'brief' parameter, but no semantics are provided for any parameter.

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

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

The description states a specific verb 'Run' and resource 'multi-agent swarm', with a clear purpose 'to edit a video from a brief'. It distinguishes from low-level editing tools like trim or add_clip, but it does not explicitly differentiate from other high-level tools such as build_narrative or assemble_from_plan, which could also be used for video creation from a brief. Still, the purpose is clear enough to convey the core function.

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

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

The description provides no guidance on when to use this tool versus its many siblings. It implies a brief is required ('from a brief') but does not state prerequisites, exclusions, or alternatives. There is no indication of when this should be preferred over tools like assemble_from_plan or make_short.

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 says only 'Save the project to JSON' and does not mention side effects like overwriting existing files, file creation behavior, failure modes, whether the save is all-or-nothing, or any impact on the current in-memory project. It gives a future agent zero information about what happens beyond the button being pressed.

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, brief sentence with no filler words; every word carries meaning. It is appropriately front-loaded with the main action. However, the extreme brevity also sacrifices needed details, so it earns a not a 5, but it is not heavy-handed or redundant.

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

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

Although the operation is conceptually simple (one string parameter, no output schema), the description omits essential context: the role of the path parameter, the meaning of 'save' (does it overwrite or create a new file?), and any interesting behavior such as formatting/scoping of the JSON. A complete description for this tool would at least say 'save the current project to the specified JSON path.' The current version leaves the agent uncertain about the exact effect.

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 ignores the single required 'path' parameter entirely. There is no explanation of what the path format should be, whether it must include a .json extension, whether directories need to pre-exist, or whether it refers to a file vs. directory. The description adds no semantic meaning beyond what a parameter name alone already implies.

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 (

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 create_project, load_project, checkpoint, or export_otio. There is no statement of prerequisites, context, or which operation should be preferred in which scenario. The reader must infer the use case 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Search', implying a read operation, but does not state whether it is read-only, what the result format is, whether it returns matches or just identifiers, or if it has side effects like building an index. For a search tool with no annotations, this is a significant gap.

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

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

The description is a single concise sentence with no filler. It front-loads the primary action and resource. While under-specified, it is efficiently written and 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 two parameters, no annotations, and no output schema, the description is far from complete. An agent cannot determine the semantics of 'index_dir', the expected return shape, error behavior, or performance implications. It is inadequate for a tool that likely involves file system access or indexing.

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-level detail. It does not explain what 'query' should contain (beyond 'by text', which is minimal), nor what 'index_dir' refers to (likely a directory path, but unstated). With two parameters and zero coverage, the description fails to compensate.

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 ('Search') and a specific resource ('semantic media index'), and qualifies it with 'by text', which maps to the query parameter. It distinguishes itself from the sibling tools, none of which are search-focused, so an agent can infer its purpose without opening the schema.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of preferred contexts, exclusions, or related tools such as 'read' or 'qc' that might also access media content. An agent is left to infer that search is appropriate for text-based lookups, but no explicit direction 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?

With no annotations provided, the description carries full responsibility for behavioral disclosure. It indicates a mutation ('Set') but does not say what happens to the clip's existing speed, whether the operation is reversible, whether duration is affected, or whether any validation or side effects occur.

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. Every word contributes to identifying the core operation, which is ideal for conciseness even though more behavioral context could be added elsewhere.

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 2-parameter mutation tool with no annotations and no output schema, the description is too sparse. An agent lacks critical information about valid speed values, units, and what the tool does to the timeline or clip beyond changing a nominal speed property.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings. It does not clarify whether 'speed' is a multiplier, percentage, or absolute value, nor does it specify allowed ranges or the format of clip_id. The parameter names are minimally self-explanatory but insufficient 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 uses a specific verb ('Set') and resource ('clip playback speed'), making the primary purpose clear. It does not explicitly contrast with sibling tools like set_volume, but the resource and property are unambiguous enough for an agent to distinguish the action.

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 set_volume, trim, or add_transition. No context is provided about prerequisites, intended workflow position, or situations where a different speed-related operation would be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action without any information about side effects, validation, error handling, or how the volume is applied. This is insufficient for a mutation tool.

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

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

The description is extremely concise, a single short sentence. It is free of unnecessary words and front-loaded with the core action. While it lacks depth, the brevity is appropriate for such 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?

For a tool with no annotations, no output schema, and no parameter descriptions, the description is severely incomplete. It omits typical volume ranges, clip existence requirements, and any notes on how the volume affects the clip. An agent would lack essential context to use this correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention what 'volume' represents (e.g., range, format, unit) or what 'clip_id' refers to. The description adds no value beyond the schema's bare property 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 'Set clip volume.' clearly states the action (set) and the resource (clip volume). It is not a tautology because it expands on the tool name by specifying 'clip' and 'volume'. However, it does not explicitly differentiate itself from sibling tools like set_speed, but the purpose is unambiguous.

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

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

There is no guidance on when to use this tool vs alternatives. It does not mention prerequisites, conditions, or comparisons to other tools. The description is too minimal to guide an agent on 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 carries the full burden of behavioral disclosure. It does not explain what happens to the original clip, whether the timeline is mutated in place, whether the operation is reversible, or whether the split produces two new clip objects.

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

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

The description is a single efficient sentence with no filler, and the core action is front-loaded. It is appropriately brief for a two-parameter tool, although the brevity does come at the cost of missing behavioral and parameter details.

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

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

With no annotations, no output schema, and 0% schema description coverage, the description is the only information source. It leaves important invocation details unknown, such as time units, error conditions, and whether the split changes the existing clip or creates new clips.

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 is the only source of parameter meaning. It adds the notion that t is a 'timeline time', but it doesn't specify units, valid ranges, or how clip_id is resolved. Only t receives any semantic clarification.

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 ('split'), a resource ('a clip'), and a location ('at timeline time t'). The operation is clearly distinct from sibling tools like trim or ripple_delete, though it does not explicitly name those alternatives.

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

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

There is no guidance on when to use this tool versus alternatives such as trim, ripple_delete, or move. The description only states what the tool does, leaving the selection decision entirely 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?

With no annotations provided, the description carries the full behavioral burden, but it discloses nothing beyond the action itself. It does not say whether the operation permanently moves clip boundaries (destructive), whether it affects all transitions or just the nearest, what happens if no beat is detected, or what is returned. For a mutation-style tool, this is a significant gap.

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

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

A single nine-word sentence with zero filler, and the core action is front-loaded. It is genuinely concise rather than bloated, though the brevity veers toward under-specification given the missing parameter and behavior context.

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

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

For a tool with no annotations, no output schema, and two unexplained parameters, this definition is too sparse. An agent needs to know what 'snap' does to the timeline, how the two track IDs relate, and the expected result. The description leaves the call's behavior materially underspecified.

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 meaning. The term 'audio track' hints at audio_track_id's role, but track_id is entirely unexplained, leaving the agent to guess which track holds the transitions. Neither parameter's type, role, or relationship is clarified.

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

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

The description uses a specific verb ('snap') and identifies both the object being modified ('clip transitions') and the target ('nearest beat in the audio track'). It is the only beat-synchronization tool among the 37 siblings, so an agent can distinguish it without opening the schema.

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

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

No usage context is provided. It does not name alternatives (e.g., trim, move, ripple_delete) or state when this tool is preferred over manual nudging. It also fails to mention prerequisites such as requiring a pre-existing audio track with detectable beats or that transitions must already exist.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not mention whether trimming is destructive, reversible, or how it affects the clip's timeline position. This is a significant gap for a mutation tool.

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

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

The description is a single, concise sentence with no wasted words, but it is under-specified for a tool with three parameters. It lacks structure and does not front-load any critical information beyond the basic action.

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

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

Given the complexity (3 parameters, no output schema, no annotations), the description is completely inadequate. It provides no context on parameter semantics, usage scenarios, or expected behavior, leaving the agent with almost no guidance.

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

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

Schema description coverage is 0%, so the description must compensate for the missing parameter explanations. However, it makes no mention of src_in, src_out, or clip_id, leaving the agent to guess their meaning and format.

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

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

The description states a specific verb 'adjust' and a resource 'a clip's source in/out', which is distinct from sibling tools like split or move. However, it doesn't elaborate on what 'source in/out' means, but the action is clear enough.

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

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

No guidance is provided on when to use trim versus alternatives like split or ripple_delete. The description only states what it does, not when it is the appropriate choice.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action but does not disclose whether the revert is destructive, whether it affects unsaved changes, whether it is reversible, or what the response looks like. This is a significant gap for a mutation-like 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 short sentence with no wasted words. It is front-loaded and easy to parse, though it could be more informative without becoming verbose.

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

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

For a tool with no parameters, no output schema, and no annotations, the description is too thin. An agent needs to know what 'checkpoint' refers to, what state is restored, and whether the operation is safe or destructive. The sibling list includes checkpoint and load_project, which makes the lack of differentiation more problematic.

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

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

The tool has zero parameters, so the schema is trivially complete. The description does not need to explain parameters, and the baseline of 4 applies because there is nothing 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 'Revert to the last checkpoint' uses a specific verb and resource, but it is vague about what 'checkpoint' means in this context and what exactly gets reverted. It does not distinguish itself from sibling tools like load_project or checkpoint, leaving an agent uncertain about scope.

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 undo versus alternatives like load_project or checkpoint. The description implies a context of reverting to a checkpoint but does not state prerequisites, limitations, or when it should be preferred over other tools.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It does not state whether the tool mutates anything, whether it requires network access for a model, how long it might take, or what it returns (e.g., a score, annotations, a report). 'Semantic review' implies analysis but not the consequences or side effects, such as whether it modifies the project or only reads the video.

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

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

The description is a single, concise sentence that immediately communicates the action and the target resource. It is front-loaded with the verb and object. However, its brevity may be a result of under-specification rather than deliberate conciseness, but as written it's efficient.

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

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

Given the complexity (3 parameters, no output schema, no annotations), the description is incomplete. It does not explain the parameters, expected output, or any behavioral context. An agent would struggle to invoke it correctly, especially without knowing what 'brief' or 'model' are for. It fails to provide sufficient guidance for a semantic review tool.

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

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

Schema description coverage is 0%, so the description must compensate. It does not explain any of the parameters (video_path, model, brief). The agent cannot infer what 'model' or 'brief' mean from the description alone. For example, it doesn't clarify that 'brief' might be instructions for the review or that 'model' selects the VLM. This is a significant gap.

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

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

The description states a specific action on a resource: it runs a VLM semantic review on a rendered video, distinguishing it from basic QC or rendering siblings. However, it is somewhat terse and doesn't detail what the review entails or what kind of output or decision it produces, leaving some ambiguity for an agent.

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 explicit guidance on when to use this tool versus siblings. It could be inferred from the name that it's for evaluating video content, but there's no indication of prerequisites (e.g., video must be rendered) or contexts where it should be preferred over QC or other analysis tools. The mention of 'rendered' hints at a post-render step, but it's not explicit.

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