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

No annotations are provided, so the description carries the full behavioral burden. It mentions the return artifacts (clips and code.py) but does not disclose whether the build overwrites files, what force/review/inspect change, permission requirements, or side effects of a mutation-like 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 single sentence is front-loaded and free of filler, which is good. However, for a five-parameter build tool with no annotations, this level of brevity is under-specification rather than appropriate conciseness.

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

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

An output schema exists, so the description need not detail return values, but the tool is complex and has five undocumented parameters. With no annotations and no sibling differentiation, the description leaves out critical behavior and usage context an agent needs to invoke it correctly.

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

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

The schema has five parameters with 0% description coverage, and the description does not explain project_id, code, force, review, or inspect. It references code.py only as an output, not as the `code` input, so the parameter semantics are effectively undocumented.

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

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

The description gives a clear compound action: build scenes, stitch video, and return clips plus code.py. It is specific enough to understand the tool's role, but it does not distinguish this tool from siblings like project_stitch or project_render_batch, leaving overlap ambiguous.

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

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

There is no explicit guidance on when to use project_build instead of project_stitch, project_render_batch, or scene_render_final. The action implies a full-project build, but the agent must infer that 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?

No annotations are provided, so the description carries the full behavioral burden. It discloses that the tool returns paths and config, but says nothing about mutation side effects, duplicate-name behavior, permission requirements, or whether creation is idempotent — all important for a create operation.

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

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

A single front-loaded sentence with the verb first and no wasted text. The trailing 'return its paths and config' is slightly redundant given the existing output schema, but it is 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?

For a mutation tool with no annotations, opaque parameters, and a complex sibling set, the description is too thin. The output schema covers return values, but behavior, parameter meaning, and routing versus project_start remain unexplained.

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

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

Schema description coverage is 0%, and the description adds no parameter detail. The theme parameter is an opaque object with additionalProperties true and a null default; the description does nothing to explain what keys it accepts or how it is used, leaving only the schema's types, enum, and defaults as 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 gives a specific verb and resource: 'Create an animation project.' This distinguishes it from read/update siblings like project_get and project_update_theme. It does not, however, differentiate it from project_start, which an agent might reasonably confuse with project creation.

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 project_start or other siblings, and no prerequisites or ordering constraints are stated. The agent must infer that 'create' means a new project and that project_start likely operates on an existing one.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the call is read-only or triggers expensive rendering, what happens if the project is unbuilt, whether it errors or blocks, or whether the bundle is streamed or written to disk — all critical for a tool whose output is a multi-artifact bundle.

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

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

A single front-loaded sentence with no wasted words; the enumeration of bundle contents is the most useful part and comes immediately after the verb. It is efficient, though the fragment style leaves the action slightly terse.

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

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

An output schema exists, so return-value explanation is not strictly needed (the description's enumeration is a bonus). However, for a tool that appears to sit at the end of a pipeline, the missing prerequisite state and error behavior leave a meaningful gap.

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

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

There is one parameter (project_id) with 0% schema description coverage, and the description never mentions it or its expected format. With no parameter documentation anywhere, the description fails to compensate for the coverage gap.

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

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

The description names a specific action ('Return') and resource ('the finished bundle') and enumerates its four artifacts (video, code.py, storyboard, report), so an agent knows exactly what comes back. It does not distinguish this from siblings like project_build, project_stitch, or project_render_final, leaving ambiguity about whether export produces the bundle or merely retrieves an already-built one.

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

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

There is no explicit when-to-use guidance, no prerequisites (e.g. whether project_build/project_stitch must run first), and no mention of alternatives among the many sibling tools. The word 'finished' hints that a prior build is required, but the agent must infer this.

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

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

With no annotations, the description carries the full disclosure burden and does add real value by naming the four payload sections returned. It does not state that the call is side-effect free, what happens when project_id is unknown, or whether the nested collections are paginated or truncated.

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

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

One front-loaded sentence with the resource first and the returned contents second; no filler, no restatement of the title.

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

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

An output schema is present, so return shapes need not be re-described, and the single-parameter surface is small. Still, a read tool with zero annotation coverage should say more about failure modes and parameter format than this one does.

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

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

Schema description coverage is 0%, so the description needed to compensate for the sole parameter and it does not — project_id is never mentioned, nor is its expected format (UUID, slug, path). The field name is self-descriptive, which prevents a 1, but nothing beyond the schema is added.

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

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

States a specific verb and resource ('Get a project') and enumerates what the payload contains (config, storyboard, scenes, status counts), which separates it from action siblings like project_build or project_export. It never names a sibling to contrast against, so differentiation is inferential rather than explicit.

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

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

Usage is only implied by the verb 'Get' — an agent can infer this is the read path for a known project_id, but the description gives no when-to-use conditions, no prerequisites, and no pointer to alternatives such as scene_list for browsing scenes.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'One worker process' reveals a useful execution trait, but the description omits critical details such as whether rendering writes files, permissions/auth requirements, failure handling, and whether mode affects 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 single sentence is front-loaded and waste-free, but its extreme brevity leaves the tool underspecified for a batch rendering operation. Conciseness is achieved at the cost of necessary detail.

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

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

An output schema exists, so return values need not be described. However, with no annotations, 0% schema description coverage, and three parameters including a mode enum, the description is not complete enough for an agent to confidently invoke this batch render 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%, and the description does not explain any of the three parameters. It vaguely references 'scenes' but gives no meaning for project_id, scene_ids, or the preview/final mode enum, leaving the agent to infer behavior from parameter names 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 verb ('Render'), resource ('scenes'), and batch scope ('many scenes in one worker process'). This distinguishes it from per-scene render tools like scene_render_preview and scene_render_final by explicitly indicating batch behavior, though it does not name those siblings.

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

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

There is no explicit guidance on when to use this tool versus scene_render_preview, scene_render_final, project_build, or project_stitch. The batch wording implies usage for many scenes, but no alternatives or exclusions are stated.

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

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

No annotations, so the description carries the full burden. It hints at an interactive prompting flow ('asking the user for any missing format parameters'), which is real context, but omits whether the call blocks on user input, what gets persisted, whether defaults are applied silently, and whether it is destructive or idempotent.

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

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

A single short sentence with no padding, but its brevity reflects under-specification rather than economy. The interactive behavior is front-loaded well enough, yet almost nothing is said.

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?

Five undocumented parameters, no annotations, and a near-identical sibling tool. The existence of an output schema relieves the description of return-value explanation, but the input and behavioral sides remain largely unfilled.

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

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

Schema description coverage is 0% across five parameters. The phrase 'format parameters' gestures vaguely at style/aspect_ratio but never names brief, style, theme, clip_count or aspect_ratio, so the agent learns nothing about required input or the meaning of the optional ones.

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

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

States a verb ('Start') and resource ('project'), but the sibling tool project_create makes the same claim, and nothing in the description distinguishes starting a project from creating one. An agent cannot tell which to pick from the text alone.

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

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

No guidance on when to use this rather than project_create, no prerequisites, no follow-up steps. The only usage hint is an implicit interaction ('asking the user'), which is not framed as a condition for choosing this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the output is an MP4 but says nothing about overwrite behavior, clip ordering, authorization requirements, duration/rate expectations, or what happens when scene_ids is null.

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

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

The single sentence is front-loaded and waste-free, with the verb and resulting artifact stated immediately. Its brevity is efficient, though it comes at the cost of missing operational detail rather than 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?

An output schema exists, so return values need not be explained. Still, with no annotations, 0% schema description coverage across three parameters, and several overlapping sibling tools, the description is too thin to let an agent call this correctly without guessing.

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

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

Schema description coverage is 0%, and the description mentions none of the three parameters. It does not explain that scene_ids selects which clips to stitch, that project_id identifies the project, or that output_name controls the resulting filename.

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

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

Names a specific verb ('Stitch') and concrete resource ('final-rendered clips into one MP4'), so the basic operation is unambiguous. However, it does not distinguish itself from related siblings such as project_build, project_export, or scene_render_final, leaving the agent to infer which composition tool applies.

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 the many nearby render/build/export siblings. There are no stated preconditions, such as whether clips must already be final-rendered or whether a prior scene_render_final call is required.

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 implies mutation but says nothing about whether the change is reversible, whether it invalidates existing renders, what permissions are required, or what "render settings" are affected.

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

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

It is a single, non-redundant sentence with the verb front-loaded, so there is no padding. However, the brevity comes at the cost of under-specification rather than efficiency.

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

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

An output schema exists, so return values need not be explained. But for a mutation tool with zero annotations, a free-form nested object parameter, and 0% schema coverage, the description is far too thin — it should at minimum explain theme structure, side effects, and preconditions.

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 theme parameter is a free-form nested object with additionalProperties=true, so its structure is completely undocumented. The description's mention of "render settings" hints that render config lives inside theme, but it provides no keys, formats, or examples to compensate for the total 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 names a verb ("update") and a resource ("project theme and render settings"), but "theme" is never defined and "validated" is ambiguous — it is unclear whether the theme must already be validated, or whether this tool validates it. It does not distinguish this tool from siblings such as project_create or project_build, which could plausibly also touch project configuration.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites (does the project need to exist first via project_create?), and no indication of when not to call it. The agent must infer everything from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether frames are written to disk, returned as encoded data, cached, or whether the call is expensive or async. For a tool that produces image artifacts, the side-effect profile is a material omission.

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

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

A single front-loaded sentence with no filler, so it is efficient. However, that brevity comes at the cost of under-specification rather than serving as disciplined conciseness. Size is appropriate; content is thin.

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

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

An output schema exists, so return values needn't be described. But for a three-required-parameter tool with zero schema coverage, the definition omits units for times and the nature of the output artifact (files vs. inline). What remains is not enough to call it correctly without trial and error.

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

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

Schema coverage is 0% and all three parameters are required, so the description should compensate. It mentions 'requested times' but never specifies units (seconds vs. frames vs. normalized 0-1), and says nothing about project_id or scene_id. The single most error-prone parameter detail, time units, is left entirely ambiguous.

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

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

The description gives a specific verb and resource: extract PNG review frames at requested times. That reads clearly as a frame-grab operation, distinguishable from siblings like scene_render_preview, scene_render_final, or scene_review. It stops short of naming or contrasting those siblings, but the core action is unambiguous.

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

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

There is no guidance on when to use this versus scene_render_preview, scene_inspect, or scene_review. The word 'review' hints at a QA/inspection workflow, but the agent must infer that this is for spot-checking specific moments rather than rendering a full sequence. No prerequisites or exclusions are stated.

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

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

With no annotations, the description carries the full behavioral burden, but it only lists returned data fields. It says nothing about read-only semantics, permission requirements, error behavior for missing scenes, or whether artifacts are expensive to fetch. Listing fields is useful but far short of what an unannotated tool needs.

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

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

A single front-loaded sentence with no filler. It is efficient, though the terseness is part of why behavioral and parameter gaps remain.

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 output schema covers the return shape, so the description needn't explain values, but the input parameters are undocumented and there are no annotations. For a read tool with many overlapping siblings, the definition leaves out the disambiguation and identifier semantics an agent needs to call it correctly.

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

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

Schema description coverage is 0% for two required parameters, and the description adds no meaning beyond the bare names project_id and scene_id. It doesn't state identifier formats, whether scene_id is scoped to project_id, or what happens when they don't match.

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

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

States a specific verb and resource ('Get a scene') and enumerates the payload it returns (plan, code, status, artifacts), which is more than a restatement of the name. It does not distinguish itself from nearby siblings like scene_inspect, scene_list, or scene_review, so an agent cannot tell from the description alone which read tool to pick.

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 indication of when to use this versus scene_inspect, scene_list, or scene_review, and no prerequisites or exclusions are given. The agent must infer selection purely from the tool name.

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

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

With no annotations at all, the description carries the full burden, yet it does disclose one non-obvious trait: no video is produced, so the agent knows this is a cheap inspection path rather than an expensive render. It says nothing about whether frames or files are written to disk, permissions, or cost, which for an unannotated tool is a real 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 front-loaded sentence with zero waste; the differentiator is placed immediately. It is arguably too terse for a three-parameter tool, but nothing in it is padding.

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

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

An output schema exists, so return values need not be described, but with zero annotation coverage and 0% schema coverage the description leaves the `times` semantics and the disk/IO side effects unexplained. For a tool sitting among many scene_* siblings, that is under-specified.

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

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

Schema description coverage is 0% and none of the three parameters are explained. The mention of 'preview frames' faintly hints at the `times` parameter, but nothing states that it takes numeric timestamps or the literal 'end', nor what 'end' resolves to.

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

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

States a specific verb (inspect) and object (layout at preview frames), and the clause 'without rendering video' separates it from scene_render_preview and scene_render_final. What 'layout' concretely covers is left vague, but the operation is identifiable.

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 'without rendering video' implies you should use this instead of a render tool when you only need a check, but no sibling is named and no when-not condition is stated explicitly. Usage must be inferred from the negation.

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

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

With no annotations, the description carries the full burden. It does disclose one genuinely useful behavioral trait — no code execution, hence no side effects — but says nothing about permissions, what happens on invalid code, or whether findings are errors vs warnings.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity borders on under-specification for a tool that must be distinguished from several siblings.

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

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

An output schema exists, so return values needn't be explained, but the description omits what linting covers, what severity of issues it reports, and when in a workflow (before scene_write?) it should be run. For a 2-required-param tool with zero schema docs and zero annotations, one sentence leaves clear gaps.

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

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

Schema description coverage is 0%, so the description must explain project_id and scene_id — and it mentions neither. The parameter names are largely self-evident, which limits the damage, but no semantics (format, whether scene_id is namespaced by project, required-ness) are added.

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

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

States a specific verb (lint) and resource (scene code) and adds the key qualifier 'without executing it', so the agent knows this is static analysis. It does not distinguish itself from near-neighbours like scene_inspect or scene_review, which an agent could plausibly confuse with linting.

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

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

There is no explicit when-to-use, when-not-to-use, or named alternative. The phrase 'without executing it' implicitly suggests using this instead of render/execute-based checks, but the agent must infer that routing decision.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only the storyboard ordering trait and does not state that this is a safe read operation, whether it requires auth, or whether pagination applies.

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

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

The description is a single front-loaded sentence with no wasted words. For a simple listing tool, the structure is appropriately tight.

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

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

An output schema exists, so return values do not need explanation in the description. However, for a tool with no annotations and a required but undocumented project_id, the description is only minimally complete: it omits project scoping and usage alternatives.

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 the required project_id parameter at all. The parameter name is fairly self-explanatory, but the description adds no explicit scoping meaning beyond the schema.

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

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

The description states a clear verb and resource: "List scenes," and adds ordering context with "in storyboard order." It does not explicitly distinguish itself from sibling tools like scene_get, scene_inspect, or scene_lint, 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 gives no when-to-use guidance, no exclusions, and no alternatives among the many scene_* and project_* siblings. Listing is implied by "List scenes," but the agent is left to infer the usage context entirely.

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

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

With no annotations, the description carries the full burden. 'Detached' is a genuine behavioral disclosure (non-blocking, external process), but it says nothing about what happens if mpv is unavailable, whether the render must exist, or whether the call blocks or errors on failure.

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

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

A single front-loaded sentence with no filler, but it is arguably too terse for a tool with three undocumented parameters rather than efficiently complete.

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

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

An output schema exists so return values needn't be explained, but for a 3-parameter tool with zero schema coverage the description leaves the mode parameter and the render prerequisite entirely unstated, which is not enough for correct invocation.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters. Critically, the 'mode' parameter (preview vs final, default preview) is the only semantically ambiguous input and the description never explains what it changes about playback.

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

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

States a specific verb ('Open') and resource ('a rendered scene') plus the delivery mechanism ('detached mpv window'), which distinguishes it from the render siblings that produce rather than display output. It does not name an explicit alternative, so sibling differentiation is only implied.

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 'rendered scene' implicitly signals a prerequisite (the scene must already be rendered), and the mode enum hints at preview vs final variants, but there is no explicit when-to-use/when-not-to-use guidance or reference to scene_render_preview/scene_render_final as the steps that must precede it.

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

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

With no annotations, the description carries the full burden: it doesn't say whether this overwrites prior renders, how long/heavy the operation is, whether it blocks, or whether approval is enforced server-side. Only the output resolution/framerate are disclosed, which is real value but leaves mutation semantics opaque.

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

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

A single front-loaded sentence that wastes no words. However it is so terse that brevity comes at the cost of necessary detail rather than from efficient packaging of it.

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

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

For a final-output mutation tool with no annotations and zero schema coverage, the description should explain the approval prerequisite, the force flag, and cost/overwrite behavior. The existing output schema covers return values, so that gap is excusable, but the input-side gaps are not.

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

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

Schema description coverage is 0% for all three parameters. The description mentions none of project_id, scene_id, or force — the purpose of the force flag (re-render over an existing final? bypass approval?) is completely undocumented.

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

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

States a specific verb and resource ('Render ... final video') plus a concrete output spec (1080p60). It implicitly distinguishes itself from scene_render_preview via 'final', but never names the sibling explicitly.

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

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

'approved' hints at a precondition but never states who or what determines approval, nor when to choose this over scene_render_preview or project_build/project_render_batch. No exclusions or alternatives are given.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it omits whether the preview is written to disk, where, whether it overwrites anything, and rough cost/time. It discloses resolution and that a report is returned, but for an operation with likely file side effects this leaves critical behavioral traits undisclosed.

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

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

A single compact sentence with the key detail (480p preview) front-loaded and no filler. Its brevity is efficient, though part of the sparseness reads as under-specification rather than deliberate conciseness.

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

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

An output schema exists, so return values needn't be explained, but the input side and behavioral profile are badly under-covered: no annotations, 0% parameter coverage, and no statement of side effects or relation to scene_render_final. For a render operation with likely writes, this is too thin to call complete.

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

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

Schema description coverage is 0%, so both project_id and scene_id are undocumented in the schema. The description does not describe them either, leaving the agent to infer their meaning and format from the parameter names 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?

Clear verb+resource: 'Render a 480p preview' tells an agent exactly what the tool does and the resolution. The word 'preview' implicitly distinguishes it from the sibling scene_render_final, but the distinction is never stated explicitly, so differentiation relies on the agent inferring from names.

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 when-to-use or when-not, and no mention of the obvious alternative (scene_render_final) or project_render_batch. Usage is only implied by the word 'preview' — an agent infers this is a cheap pre-check before a final render, but nothing confirms that intent.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether approval is irreversible, what rejecting does to the scene or downstream rendering, whether a reason is required for rejection, or what permissions/state preconditions are needed. For a mutation-style decision 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?

The single sentence is front-loaded and free of waste, but for a four-parameter mutation tool with no annotation coverage it is under-specified rather than optimally concise.

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

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

An output schema exists, so return values need not be explained. But with zero annotation coverage and zero parameter descriptions, the definition leaves out critical context about state transitions, rejection consequences, and parameter usage, which an agent needs before invoking this tool.

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

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

Schema description coverage is 0%, and the description only alludes to the decision parameter via 'approve or reject'. It adds no meaning for project_id, scene_id, or reason, such as whether reason is required on rejection or how scene_id relates to project_id.

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

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

The description states a specific action pair (approve or reject) on a specific resource (a previewed scene), and the word 'previewed' ties it to the preview/render workflow rather than to siblings like scene_write or scene_list. It is clear enough to distinguish this from most siblings, though it does not name a direct 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?

'Previewed scene' implies this should be used after scene_render_preview, giving some contextual usage guidance. However, there is no explicit when/when-not statement, no mention of prerequisites, and no direct routing to or from 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?

With no annotations, the description carries the full behavioral burden; it does disclose notable side effects: resetting status and clearing stale artifacts. However, it omits whether existing source is overwritten, required permissions, validation behavior, and what 'stale artifacts' means.

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

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

A single front-loaded sentence with no wasted words; the main action appears first and the side effects follow compactly.

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

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

For a mutation tool with no annotations and an output schema, the description gives useful side-effect context but not enough for fully safe invocation. It does not cover overwrite semantics, prerequisites, or failure behavior, though the output schema removes the need to explain return values.

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

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

Schema description coverage is 0%, so the description must compensate, but it only loosely maps 'scene source' to the code parameter and says nothing about project_id or scene_id. An agent is left to infer all three parameters from their names.

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

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

The description uses a specific verb (Write) and resource (scene source), and adds side-effect details (resetting status, clearing artifacts). It implicitly distinguishes scene_write from read/render siblings like scene_get and scene_render_preview, though it never names an alternative explicitly.

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

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

There is no explicit guidance on when to use scene_write versus siblings, no prerequisites, and no warnings or exclusions. Use is only implied by the verb 'Write' and the mention of clearing artifacts.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuine behavioral trait beyond the name — the payload is validated before being persisted, so invalid storyboards will be rejected — but says nothing about overwrite/replace semantics for an existing storyboard, idempotency, or what a validation failure looks like.

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

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

A single eight-word sentence with zero waste and the operative verb front-loaded. It is efficient, though its terseness edges toward under-specification rather than optimal 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?

This is a write operation with a deeply nested payload, no annotations, and an output schema (so return values needn't be explained). Given the complexity, essential context is missing: whether saving replaces an existing storyboard, how validation failures surface, and where this fits relative to scene_write and the render/build siblings.

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

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

Schema description coverage is only 50%: the required top-level 'project_id' and 'storyboard' properties have no schema descriptions, while nested clip/beat properties are documented. The description adds nothing about either required parameter — not what project_id scopes, nor that 'storyboard' is the same nested shape produced by a planning step.

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

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

States a specific verb pair ('validate and persist') and a specific resource ('a storyboard and its planned scenes'), which distinguishes it from scene_write (single scene) in the sibling list. However, it never names a sibling or states the relationship to the storyboard-planning flow, leaving differentiation implicit.

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

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

No when-to-use, when-not-to-use, or prerequisite guidance. With siblings like scene_write, project_build, and project_render_batch in the same list, an agent gets no signal about whether saving a storyboard is a required step before building, or what to do if a storyboard already exists.

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