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

With no annotations, the description carries the full behavioral burden, yet it only implies non-destructive versioning via 'in a new shot version' and hints at clamping via 'bounded'. It says nothing about permissions, idempotency (despite a request_id parameter), what happens on repeat calls, or failure modes for a mutating pipeline 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 no filler, which is efficient and easy to parse. It is arguably too terse for a five-parameter mutation tool, but nothing in it wastes the reader's time.

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 the rest is thin: no parameter meaning, no behavioral disclosure, and no routing against siblings for a tool that creates a new shot version. An agent could guess the intent but not invoke it confidently without inspecting the schema.

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

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

Schema description coverage is 0% across five parameters, so the description must compensate, but it names none of them. Only 'bounded' loosely gestures at the strength parameter; the roles of project_root, shot_id, source_version, and request_id are completely undocumented in both the schema and the 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 states a specific verb (add) and resource (bounded procedural secondary motion) and notes that it lands in a new shot version, which is concrete enough for an agent to identify the operation. It stops short of differentiating itself from plausible siblings like animate_shot or sync_lips, so it relies on domain knowledge of what 'secondary motion' means.

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 reach for this tool versus animate_shot, sync_lips, or other shot-stage siblings, and no prerequisites are stated (e.g., whether an animated source_version must already exist). Usage is left entirely to inference 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 adds one useful trait ('deterministic'), but omits mutation semantics, permission requirements, overwrite behavior, and what 'blocking' implies for the created animation.

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, but for a six-parameter creation tool with no schema descriptions it is under-specified rather than appropriately concise. Brevity here leaves critical gaps.

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

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

The tool is complex: six parameters, no annotations, and 0% schema description coverage. Although an output schema exists and reduces the need to describe return values, the description still fails to cover input semantics, prerequisites, or usage context, making it inadequate overall.

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 six parameters, and the description mentions none of them. Required inputs such as project_root, shot_id, source_version, and request_id are left entirely undocumented in both schema and description.

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

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

The description gives a specific verb ('Create') and a resource ('blocking-animation version'), but the object being animated is implied rather than stated and no sibling differentiation is provided. It is clearer than a tautology, yet an agent cannot tell from the text alone what kind of shot/asset this applies to.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as create_shot, assemble_shot, or add_secondary_motion. The description offers no routing information beyond 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 provided, the description carries the full burden, and it does disclose the key trait that everything is retained ("while retaining every file and record"). However, it is silent on permissions, reversibility/restore path, and whether archiving is idempotent — meaningful gaps for a mutation with six required parameters.

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

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

A single front-loaded sentence with no filler; the effect clause ("while retaining every file and record") is placed immediately after the action. Efficient, though its brevity is partly under-specification rather than true 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 need not be described. But for a six-required-parameter mutation with no annotations, the definition omits parameter semantics, auth/prerequisite context, and restore behavior — insufficient for an agent to call it reliably.

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?

Six required parameters with 0% schema description coverage and no enums; the schema gives only titles like "Reason" and "Request Id." The description explains none of them — not project_root scope, not asset_type/asset_id identity, not version format, not the role of request_id or reason. It adds nothing over the structured field names.

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

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

States a specific verb+resource ("Archive ... version") and narrows it with "unpromoted," which implicitly separates it from the sibling promote_version. It does not explicitly name that sibling, so it stops short of a 5, but the action and subject are 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?

The qualifier "unpromoted" implies the condition under which archiving applies, but there is no explicit when-to-use guidance, no mention of prerequisites, and no reference to promote_version or any alternative in a 28-tool sibling set. The agent must infer routing.

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

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

No annotations are provided, so the description carries full burden. It doesn't mention whether this creates a new version, mutates existing state, requires locking, or has side effects. 'Assemble' implies composition but the description stops there.

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

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

Single short sentence with no waste, front-loaded with the action. It's concise but arguably under-specified rather than genuinely dense with information.

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

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

Given 5 params, a nested object, no annotations, and no output schema explanation, the description is far too thin. An agent cannot confidently call this without guessing at 'asset_versions' structure and side effects.

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

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

Schema description coverage is 0% across 5 required parameters including a nested object. The description doesn't explain 'asset_versions' mapping semantics, what 'source_version' vs 'asset_versions' means, or the role of 'request_id' for idempotency.

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 ('Assemble... into a new shot version'), which is clearer than a tautology. However, it doesn't differentiate from siblings like 'promote_version' or 'create_shot', and 'exact character versions' is ambiguous without schema context.

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 guidance, no prerequisites, and no mention of alternatives like 'promote_version' or 'create_shot'. The agent must infer when assembling vs promoting vs creating 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 the full behavioral burden and does not meet it. It implies a mutation (creating shape keys) and a dependency on a 'rig-approved exact' version, but says nothing about permissions, reversibility, side effects on existing keys, or execution cost.

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. It is arguably too terse given the complexity, but on the conciseness dimension it wastes nothing.

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 for a mutation tool with five parameters, zero schema coverage, and no annotations, the description is far too thin to guide 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 all five parameters are undocumented in the schema. The description gestures at 'source version' and 'facial shape keys' (likely blendshape_set), but project_root, character_id, and request_id are left completely unexplained.

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

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

States a specific verb (Create) and resource (facial shape keys), which implicitly distinguishes it from the broader rig_character sibling. However, it does not name an alternative or clarify how it relates to rig_character, so the differentiation is inferred rather than stated.

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

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

There is no explicit when-to-use guidance or mention of alternatives such as rig_character. The phrase 'rig-approved exact source version' hints at a precondition, but it is never spelled out as a usage rule.

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

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

With no annotations, the description carries the full burden, and it does contribute one meaningful nuance: 'Request cancellation' implies the cancellation is asynchronous or best-effort rather than an immediate guaranteed teardown. However, it omits permissions required, what happens to partially produced output, and whether the action is reversible, so the disclosure is thin for an unannotated mutation tool.

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

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

One front-loaded sentence with no filler; the scope qualifier 'queued or running' is placed before the object of the verb. It is efficient, though arguably undersized for a mutation tool that needs more behavioral 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. But against zero annotations and zero parameter documentation, the description omits permissions, cancellation semantics, and failure modes for a destructive-ish operation on a live job, which is not complete enough for an agent to call it confidently.

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

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

Schema description coverage is 0% across both required parameters, so the description must compensate and largely does not. 'Exact ... job' hints that job_id is matched literally rather than by prefix, and project_root is unexplained (path vs. identifier), leaving the agent to guess at both parameter formats.

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

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

The description states a clear verb+resource ('cancel ... production job') and narrows scope to 'queued or running' jobs. It is distinguishable from siblings like resume_job and get_job_status by implication, but it never names them or otherwise explicitly contrasts its role in the job family, so it stops short of a 5.

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

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

There is no statement of when to choose this over get_job_status or resume_job, and no prerequisites or exclusions. The only guidance is the embedded state constraint ('queued or running'), which is a precondition rather than usage direction, leaving the agent to infer the rest.

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 hints that comparison covers metadata and artifact hashes, which is useful, but it does not clarify whether this is read-only, what happens on version mismatch, or any permission requirements. The disclosure is thin for a mutation-capable environment.

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 its brevity contributes to the gaps in other dimensions rather than being tight but 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 need not be explained, but for a five-parameter tool with 0% schema coverage and no annotations, the description leaves too much unstated: parameter roles, whether it is safe/read-only, and when a comparison is appropriate. It is inadequate for the tool's complexity.

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 description implies left_version/right_version semantics through 'two exact asset versions' and references asset context, but project_root, asset_type, and asset_id receive no semantic explanation anywhere, leaving most parameters 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 states a specific verb (Compare) and resource (metadata and artifact hashes of two exact asset versions), which is more precise than the bare tool name. However, it does not differentiate itself from siblings like inspect_asset or inspect_project that could also expose version data, leaving some ambiguity 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?

There is no indication of when to use this tool versus alternatives such as inspect_asset (single asset) or promote/archive_version (mutations). No prerequisites or context for invoking a comparison 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. 'Deterministic' hints at repeatability, but it says nothing about permissions, idempotency semantics, what request_id does, whether existing characters are overwritten, or what side effects occur on disk.

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

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

One front-loaded sentence with no filler, though the extreme brevity comes at the cost of the missing parameter and behavioral detail rather than being purely economical.

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 for a 7-parameter creation tool with zero annotation coverage and zero schema descriptions, the description leaves far too much unspecified for an agent to call it confidently.

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

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

Schema description coverage is 0% across 7 parameters. The description explains only 'reference_version' implicitly; project_root, character_id, request_id, style, height_m, and body_type are entirely undocumented in both schema and description.

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

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

States a specific verb ('Create') and resource ('character blockout') plus two distinguishing qualifiers: determinism and the optional reference version. It is reasonably separable from create_character_mesh, though that sibling is never named.

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 'optionally from an exact reference version' implies when to supply a reference, but there is no explicit when-to-use/when-not guidance and no routing to create_character_mesh or import_character_reference, which would be the obvious alternatives.

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

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

No annotations are provided, so the description carries the full burden. It does not disclose whether this is a long-running job (and whether request_id is for idempotency/polling), what permissions or project state are required, or what side effects the creation has on the source version. For a mutation 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?

A single efficient sentence with the action front-loaded, so nothing is wasted. However, it is under-specified rather than genuinely concise — the brevity leaves the core behavioral and parameter questions unanswered.

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 for a 5-parameter creation tool with no annotations and 0% schema coverage, the description omits the pipeline context, prerequisites, and parameter meanings 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?

Schema description coverage is 0% across 5 parameters, and the description only hints at source_version via 'from one exact character version.' It says nothing about project_root, character_id, request_id (likely an idempotency/dedup key), or subdivision_levels, leaving four required/optional parameters unexplained in both schema and prose.

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 ('create a mesh version') and adds the scoping detail 'from one exact character version,' which separates it from create_character and retopologize_character. It does not explicitly name a sibling alternative, but the resource is distinctive enough that an agent can place 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?

There is no guidance on when this step belongs in the character pipeline versus retopologize_character, create_uv_and_materials, or groom_character. The only implied condition is that a source character version must exist, which is inferred from 'from one exact character version' rather than 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 and falls short. It never explains that this is a mutation, whether it is idempotent or what request_id does (likely a dedupe/idempotency key), what happens if the shot already exists, or whether files are written to disk. 'Explicit frame range' hints that defaults may not apply, but nothing about the 1-120 defaults in the schema is clarified.

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 well-structured, though the brevity is driven by omission rather than efficiency, since there is almost no content to trim.

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

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

For a six-parameter mutation tool with no annotations and no parameter descriptions, the description is far too thin. Although an output schema exists (so return values need not be explained), the agent still lacks the required-parameter meaning and write/idempotency semantics it needs to call 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% across six parameters, so the description must compensate and largely does not. It alludes to the frame range (frame_start/frame_end) but says nothing about project_root, shot_id, fps, or the required request_id, leaving most parameters semantically opaque.

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 ('Create a new shot layout') plus a scope detail ('with an explicit frame range'), so an agent knows the core action. It does not differentiate from adjacent siblings such as assemble_shot or setup_camera, but the purpose itself 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 when-to-use guidance, no prerequisites, and no mention of alternatives like assemble_shot. The only contextual hint is that the frame range must be given explicitly, which does not tell the agent when this tool is the right choice versus its siblings.

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

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

No annotations are provided, so the description carries the full burden. It hints at versioning by saying a 'new look-development version' is created, but it does not state whether the operation is idempotent, what happens if a version already exists, what permissions are needed, or how long it takes.

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

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

A single efficient sentence with the action front-loaded and no filler. It is arguably too terse for the number of parameters it hides, but nothing in the sentence is wasted.

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

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

An output schema exists, so return values need not be explained, but for a 6-parameter mutation tool with no annotations the description leaves the key inputs and their semantics entirely unexplained. An agent could not determine what source_version or request_id mean from this text alone.

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

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

Six parameters with 0% schema description coverage, and the description names none of them. The required project_root, character_id, source_version, and request_id are completely undocumented, and the optional roughness/base_color are only obliquely implied by the word 'material'.

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 two resources ('create UVs and a material') plus the destination context ('a new look-development version'), which distinguishes it from retopologize_character or groom_character. However, it gives no explicit sibling differentiation, so an agent must infer the pipeline position.

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

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

No guidance on when this step should be run relative to siblings such as retopologize_character, rig_character, or promote_version, and no stated prerequisites. The agent is left to infer that a source_version 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, the description carries the full behavioral burden. It does disclose two useful traits — that the status is persistent (retrievable after the fact) and that the result is included — and 'Read' implies a non-mutating operation. It says nothing about behavior for an unknown job_id, polling frequency, or whether status can be stale/eventually consistent.

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

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

A single front-loaded sentence with no filler, and the purpose is stated immediately. It is efficient, though the brevity comes partly at the cost of the missing parameter and usage detail rather than being purely economical.

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, and the tool is a simple two-parameter read. However, with no annotations and 0% parameter coverage, the definition leaves project_root's role and the relationship to cancel_job/resume_job entirely 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% and the description compensates for almost none of it. The word 'job' weakly implies job_id, but project_root — a required parameter — is never mentioned, so the agent gets no guidance on what it is or how it scopes the lookup.

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

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

The description states a specific verb (Read) and resource (persistent status and result of a long production job), which is clearly distinct from the mutation siblings cancel_job and resume_job. It never names those siblings or explicitly contrasts itself with them, so it stops short of full sibling differentiation.

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

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

Usage is only implied: an agent can infer this is the tool to poll after kicking off a long job. There is no explicit when-to-use, no statement of prerequisites, and no reference to the adjacent cancel_job/resume_job tools that operate on the same job_id.

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, yet it only adds the source-version precondition. It does not say whether this is a long-running job (siblings get_job_status/cancel_job hint at async), whether it requires approval gates, whether it overwrites existing grooms, or what permissions are needed.

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

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

A single front-loaded sentence with no filler; the core action and its source constraint come first. It is efficient, though its brevity borders on under-specification rather than tightness.

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 6 parameters, 4 of them required, zero schema coverage, no annotations, and no output-schema documentation needs, the description is far too thin. It should at minimum clarify the approval gate, the job/async nature, and the meaning of the required identifiers.

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 6 parameters, and the description only gestures at source_version ('exact source version'). The required project_root, character_id, request_id and the optional style and strand_count receive no explanation in either the schema or the 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?

States a specific verb (create) and resource (groom), with an added constraint that the source must be an 'appearance-approved exact source version'. This is clearly distinguishable from mesh, rig, and UV siblings, though it does not name any 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?

The phrase 'appearance-approved exact source version' implies a prerequisite, but it is never framed as guidance and there is no statement of when to use this tool versus alternatives like create_character_mesh or retopologize_character. No exclusions or sequencing 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 burden. It does disclose two useful traits: the operation copies (rather than moves) and the result is an immutable version, implying existing versions are untouched. It omits error behavior, idempotency/retry semantics (despite a request_id parameter hinting at that), and any permission requirements.

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

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

A single short sentence with no filler, and the key outcome (a new immutable version) is front-loaded. Nothing in it is redundant.

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

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

An output schema exists, so return values need no explanation, but with four required parameters at 0% schema coverage and zero annotations, the definition is materially incomplete. It never clarifies how project_root and character_id relate, whether request_id provides idempotency, or what a caller must do before invoking it.

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 four required parameters, so the description must compensate and does not. Only reference_files is loosely hinted at by 'reference images or files'; project_root, character_id, and especially request_id are never explained, leaving their roles and expected formats to guesswork.

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 (copy), a resource (reference images or files), and a destination (a new immutable character version), so an agent knows exactly what the tool produces. It does not explicitly contrast itself with siblings such as create_character or promote_version, which prevents a 5.

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

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

There is no guidance on when to use this tool versus alternatives, nor any stated preconditions such as whether the character must already exist or whether the source files must be validated first. The single sentence describes what happens, not when it is the right 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. It does disclose read semantics and that versions are immutable, but says nothing about permissions, behavior when the version is absent, or the difference in output between the two modes.

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

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

A single front-loaded sentence with zero filler; the primary read behavior leads and the version variant follows. Nothing could be trimmed without losing meaning.

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

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

An output schema exists, so return values need not be explained, and the core state-vs-version distinction is covered. However, for a four-parameter tool with 0% schema coverage, the description leaves asset_type/project_root semantics and the optionality of version 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% across four parameters, so the description must compensate and largely does not. Only "version" is hinted at via "one exact immutable version"; project_root, asset_type, and asset_id carry no added meaning, nor does it clarify that version is optional.

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 ("Read") and resource ("one asset") plus the two modes of inspection: lifecycle state or an exact immutable version. This clearly separates it from list_assets and compare_asset_versions, though it never names a 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?

The two modes imply when to use it (single-asset lookup, or pinning a specific version), but there is no explicit when-to-use/when-not guidance and no pointer to alternatives like list_assets for bulk reads or compare_asset_versions for diffs.

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 at least self-declare read-only behavior ('without modifying it'), which is the key safety trait here. However, it discloses nothing about permissions, scope limits, failure modes, or how stale/fresh the counts and job state are.

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

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

One front-loaded sentence with no padding; scope and the read-only constraint are both stated immediately.

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

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

An output schema exists, so return values need no explanation, and the operation is a simple single-parameter read. The remaining gap is the undocumented project_root argument, which leaves the definition slightly short of complete.

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

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

The single parameter project_root has 0% schema description coverage and no description text either, so the agent gets no guidance on format (absolute path, repo root, workspace id). With one param and no schema help, the description should 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?

States a specific verb (read) and resource (project counts, configuration, active-job state) with the non-mutating qualifier. It is broadly distinguishable from siblings like inspect_asset and get_job_status, though the overlap with job-state reporting is not explicitly disambiguated.

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 guidance, no prerequisites, and no mention of alternatives such as inspect_asset or get_job_status despite the sibling overlap on job state. The agent must 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?

No annotations are provided, so the description carries the full burden. It implies a mutation (creating a new version) but does not disclose permissions, reversibility, side effects on source_version, or how the preset is selected. Only the bare fact of creation is stated.

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

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

The single sentence is front-loaded and free of filler, but it is severely under-specified for a six-parameter mutation tool. Brevity here reflects missing content rather than efficient communication.

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 with no schema descriptions, no annotations, and no output schema explanation needed, the description is far too sparse. It omits parameter semantics, usage conditions, and behavioral details that an agent needs to invoke 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% for six parameters. The description mentions 'preset' but does not explain its default ('three_point'), nor does it clarify required parameters like project_root, shot_id, source_version, or request_id. It adds almost no semantic value beyond the parameter names.

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

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

States a specific verb (Create) and resource (lit shot version), and adds the mechanism (fixed production preset). It distinguishes from generic create_shot and render tools, but does not explicitly contrast with siblings like assemble_shot or setup_camera.

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 context, no prerequisites, and no alternatives are mentioned. The phrase 'using a fixed production preset' hints at a lighting pass, but gives no guidance on when this tool is appropriate versus render_shot_preview or create_shot.

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, yet it only implies a read operation. It says nothing about permissions, pagination, cost, or whether archived items are excluded by default. The presence of an output schema reduces the need to explain return values, but the operational behavior remains 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 front-loaded sentence with no filler, which is appropriately sized for a list tool. It is efficient rather than padded, though it errs toward under-specification rather than true completeness.

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 three undocumented parameters, no annotations, and no usage guidance, the definition is too thin for a tool that anchors a large sibling family. An agent lacks enough to invoke it with the right filters.

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, so the description must compensate and does not. "Character and shot" loosely hints at the asset_type domain, but project_root and include_archived are never explained, and the asset_type filter values are left unstated.

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

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

The description gives a clear verb ("List") and resource ("character and shot identities plus their explicit versions"), so an agent knows the general shape of what it returns. However, it does not distinguish this tool from near-neighbors like inspect_project or inspect_asset, which could plausibly also enumerate assets, leaving the boundary 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 statement of when to use this tool versus the many siblings (inspect_project, inspect_asset, compare_asset_versions). The agent must infer that this is the entry-point enumeration call, and nothing warns about when it is the wrong 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 behavioral burden and mostly fails it. It discloses only the output artifact type (versioned ZIP); it does not state where the ZIP is written, whether the operation requires specific permissions, whether it mutates project state, or whether it is idempotent across repeated request_id values.

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

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

A single, front-loaded sentence with zero filler; the scoping constraint ('one exact ... version') leads. It is efficient, though its brevity reflects under-specification rather than disciplined 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 need not be described, but for a five-parameter, all-required mutation tool with no annotations and 0% schema coverage, the description leaves the input contract, permissions, and side effects unexplained. It is not complete enough for confident invocation.

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

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

Schema description coverage is 0%, so all five required parameters are undocumented in the schema, and the description only loosely gestures at asset_type/asset_id/version via 'character or shot version'. project_root and request_id receive no explanation at all, leaving half the contract opaque.

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 (package), a precise resource (one exact character or shot version), and the outcome (a versioned ZIP). It is distinguishable in kind from the many sibling create/render/inspect tools, though it does not explicitly name its closest sibling package_episode to disambiguate the asset-level vs episode-level 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?

The description gives no when-to-use, when-not-to-use, or alternative guidance. The word 'exact' hints at a precision requirement for version selection, but an agent is not told when packaging is appropriate versus promote_version or archive_version.

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

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

With no annotations provided, the description carries the full behavioral burden, and it falls short: it does not state required permissions, whether the operation is idempotent, whether an existing package is overwritten, or what 'versioned' implies for repeated calls. The presence of a request_id strongly suggests idempotency semantics, yet the description never explains this. The only disclosed behavior is that a ZIP is produced.

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; every word earns its place. It is arguably too terse for a four-parameter mutation tool, but the deficiency lies in coverage, not in verbosity.

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

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

An output schema exists, so return values need not be described. But for an artifact-producing tool with zero annotations, zero schema coverage, and a nested object parameter, the description omits too much: idempotency behavior, overwrite semantics, and the meaning of request_id are all left 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% and all four parameters carry only bare titles. The phrase 'caller-selected exact shot versions' loosely maps to shot_versions and 'episode' to episode_id, but project_root and request_id receive no explanation at all, and the expected shape of the shot_versions map (version strings keyed by shot) is left unstated.

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

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

The description gives a specific verb (package), a clear resource (episode), the input granularity (caller-selected exact shot versions) and the artifact produced (versioned episode ZIP). However, it makes no attempt to distinguish this from the sibling package_asset, which an agent could easily confuse it with.

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 package an episode versus when to package an asset, no prerequisites, and no mention of the closely named sibling package_asset. The agent must infer all routing from the name alone.

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

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

With no annotations provided, the description carries the full behavioral burden. It usefully discloses one non-obvious trait: promotion is byte-immutable metadata approval rather than a content mutation. However, it omits reversibility, permission/auth requirements, the meaning of the gate, and the idempotency implied by request_id.

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

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

A single front-loaded sentence with zero filler. Every clause (approve, exact version, named gate, byte-immutability) earns its place.

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

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

This is a 8-parameter, 7-required mutation tool with no annotations and 0% schema coverage, and an output schema that only relieves return-value explanation. The description is far too thin for that complexity — gate vocabulary, reviewer identity, and idempotency/rollback behavior all go 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% across all 8 parameters, so the description must compensate but does not. It loosely maps to 'version' and 'gate', yet gives no semantics for asset_type, asset_id, reviewer, request_id, project_root, or notes — an agent cannot tell formats or allowed values from either source.

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 (approve/promote) and resource (an exact version) plus the scoping concept (a named review gate). The phrase 'without changing its bytes' also distinguishes it from byte-mutating siblings like archive_version or retopologize_character. It stops short of explicitly naming an alternative, 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 explicit guidance on when to use this tool versus siblings such as compare_asset_versions, archive_version, or validate_character. The scenario is only implied by 'at a named review gate'. No prerequisites (e.g. prior validation, permissions, ordering) are stated.

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

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

With no annotations, the description carries the full burden. It does disclose that a new version is created (a side effect) and ties the output to an approval gate, but it omits whether the render is expensive/async, whether it requires permissions, what happens to prior versions, or how failures surface.

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 appropriately sized, though its brevity comes partly from under-specification rather than disciplined editing.

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 the definition leaves 7 undocumented parameters, no usage guidance, and no annotation-backed behavioral context for what appears to be a version-creating render operation. Too thin for the tool's complexity.

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 7 parameters, including required ones like project_root, character_id, source_version, and request_id, plus optional angle_count, resolution_x, and resolution_y. The description adds no information about any of them, so it 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?

States a specific verb (render) and resource (review artifact) and adds a scope hint (new version, approval gate). However, 'review artifact' and 'explicit approval gate' are jargon that don't clearly tell an agent how this differs from sibling render tools like render_shot_preview or render_shot_final, so purpose is only partly distinctive.

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 guidance, no prerequisites, and no named alternative. The phrase 'for an explicit approval gate' hints at context but doesn't tell an agent when to pick this over promote_version, compare_asset_versions, or the shot render tools.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does little. It implies a write/mutation that produces a new version, but never discloses that rendering is likely long-running or job-based (the get_job_status/cancel_job siblings hint at async behavior), nor any auth or cost implications.

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 clean, front-loaded sentence with no filler. It is efficient, though for an 8-parameter mutation tool it leans toward under-specification rather than being appropriately sized.

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 complex render/publish operation with 8 parameters, no annotations, and 0% schema coverage, one sentence is far too thin. The output schema covers return values, but nothing explains parameters, preconditions, or the job workflow an agent must orchestrate.

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% across 8 parameters, so the description must compensate and essentially does not. It hints at 'source' (source_version) and 'final-render version', but frame range, resolutions, project_root, and request_id go entirely unexplained.

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

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

States a specific verb (Render) and resource (a new final-render version) and specifies the input as an 'animation-approved source'. The word 'final' implicitly contrasts with the sibling render_shot_preview, though the distinction is never made 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?

The phrase 'animation-approved source' implies a precondition (animation must already be approved), which is useful implied guidance. However, it names no alternative and gives no when-not-to-use conditions versus render_shot_preview or render_character_review.

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

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

With no annotations at all, the description carries the full behavioral burden. It implies a mutation (creating a 'new preview version') but never states that this is likely a long-running async job requiring polling via get_job_status, what permissions or prerequisites are needed, whether the source version is preserved, or how failures surface. For an 8-parameter render tool with zero annotation coverage, this is a substantial disclosure 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 no filler, which is structurally sound. It is arguably under-specified rather than bloated, but there is no wasted text to penalize.

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 that is the only mitigating factor. For a tool with 8 undocumented parameters, no annotations, and a sibling get_job_status suggesting asynchronous execution, the description leaves critical operational context missing.

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

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

Schema description coverage is 0% across 8 parameters, so the description must compensate and largely fails to. Only a faint hint connects 'review sequence' to frame_start/frame_end and 'new preview version' to source_version; project_root, request_id, and resolution_x/y receive no semantic treatment whatsoever.

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 (render) and resource (a review sequence rendered into a new preview version), which is enough to distinguish it from the closely named sibling render_shot_final by signaling 'preview' rather than 'final'. It stops short of any explicit sibling differentiation, so it sits at a clear-but-undifferentiated 4.

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 statement of when to use this tool versus render_shot_final or render_character_review, which are the obvious alternatives for a render request. The agent is left to infer the preview/final distinction entirely on its own.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It notes that work resumes under the same stable job ID, which is useful, but it does not disclose permissions, side effects, idempotency, or what happens to partially completed work. For a mutation-like job-control 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 front-loaded sentence with no filler. Every word contributes to defining the action and the states it applies to.

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 takes two required parameters with no schema descriptions and no annotations, and the description does not fill those gaps. An output schema exists, which mitigates the need to explain return values, but the definition remains incomplete regarding parameter meaning and precise usage boundaries.

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 only indirectly references job_id through 'same stable job ID' and says nothing about project_root or the distinction between a stable job ID and a new one. Parameter meaning is largely left to the schema 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 clearly states a specific verb (resume) and resource (failed, cancelled, or interrupted work) and adds a key scoping detail (same stable job ID). It distinguishes the operation from general job creation or status checks, though it does not explicitly name or contrast with sibling tools like get_job_status or cancel_job.

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

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

The description implies when to use it by listing job states (failed, cancelled, interrupted), but gives no explicit when-not conditions or alternatives. It does not say whether to check get_job_status first or how this differs from other job-control 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, the description carries the full burden. It does add one genuine behavioral fact — the operation is 'non-destructive', i.e. it produces a version rather than overwriting the source — which is real value beyond structured data. However it says nothing about whether this is a long-running/async job (the get_job_status/cancel_job siblings suggest jobs exist), what permissions are needed, or whether source_version must already exist.

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

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

A single tight sentence with the key scope trait ('non-destructive') front-loaded and no filler. It is appropriately sized for its content, though the brevity is partly under-specification rather than discipline.

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 means return values need not be described, but for a 5-parameter, 4-required mutation-style tool with zero schema coverage and no annotations, the description omits required-parameter meaning, optionality of target_faces, and pipeline prerequisites. Not sufficient 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% across 5 parameters, so the description must compensate. It only accounts for 'target_faces' via 'target face budget' and does not mention that target_faces is optional (default 12000), nor what project_root, character_id, source_version, or request_id mean or require.

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 ('Create a ... retopology version') plus two distinguishing traits: 'non-destructive' and 'target face budget'. It is clearly separable from mesh/rig/groom siblings, though it does not explicitly name an alternative tool.

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 guidance, no prerequisites, and no placement in the pipeline (e.g. that it should follow create_character_mesh or a sculpting stage, and precede create_uv_and_materials/rig_character). The agent must infer all sequencing.

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

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

With no annotations, the description carries the entire behavioral burden. It discloses one useful precondition (the source must be groom-approved and exact), but says nothing about side effects, whether a rig asset/version is created, idempotency implied by request_id, or whether this runs as an async job tracked by get_job_status.

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

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

A single front-loaded sentence with no filler; the key constraint (groom-approved exact source) appears immediately.

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

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

An output schema exists, so return values need not be explained, but for a 5-parameter mutation tool with zero annotation and zero schema-description coverage the one-liner is materially incomplete — key inputs and behavioral traits go unaddressed.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. It only loosely gestures at source_version ('exact source version') and covers none of project_root, character_id, rig_type, or request_id, leaving their meaning and role 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+resource (create a rig) plus a scoping constraint (from a groom-approved exact source version), which distinguishes it from generic siblings like create_character_mesh. It does not, however, explicitly distinguish itself from build_face_rig, which also produces rig data.

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 'groom-approved exact source version' phrase implies a prerequisite stage (grooming must be complete and approved), giving implicit when-to-use guidance. There is no explicit statement of alternatives or when-not to use this tool.

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

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

With no annotations, the description carries the entire behavioral burden, and it discloses almost nothing: it does not say whether this mutates the project, whether it is idempotent, what request_id is for, or what happens if a camera version already exists for the shot. Only the bare fact of a creation operation is conveyed.

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

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

It is a single front-loaded sentence with no filler, which is structurally clean, but at this level of brevity for a 7-parameter mutation tool the terseness reads as under-specification rather than 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?

An output schema exists, so return values need not be described. However, for a 7-parameter, 4-required mutation tool with no annotations and 0% schema coverage, the description is far too thin — units, coordinate format, idempotency, and failure modes are all missing.

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

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

Schema description coverage is 0% across 7 parameters, and the description names none of them. Critical fields like target, position, lens_mm (with a default of 50), request_id, and project_root are entirely unexplained in both schema and description, leaving the agent to guess at units, coordinate conventions, and idempotency 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 names a verb ("Create") and a resource ("camera version") but leaves both terms undefined — an agent cannot tell what a "camera version" is or what constitutes a "shot source" in this pipeline. It is distinguishable from siblings only because no sibling deals with cameras, not because the description draws the 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 statement of when to use this tool versus alternatives, no prerequisites (e.g., must a shot already exist, must it be assembled first), and no indication of ordering within the shot workflow. The only implicit signal is that it belongs to shot setup, inferred from the name alone.

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

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

With no annotations provided, the description carries the full behavioral burden, and it discloses very little. It does not say whether applying cues overwrites existing lip-sync data on the version, whether the operation is idempotent, what permissions are needed, or whether it is synchronous. Only the 'exact shot version' targeting hint is added.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though the terseness is part of what leaves the behavioral and parameter gaps unfilled.

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. However, for a mutation tool with no annotations, five required parameters, and 0% schema coverage, the description omits prerequisites, overwrite semantics, and cue format, leaving an agent under-informed before calling it.

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 required parameters, so the description must compensate. 'Frame/value mouth cues' loosely describes the cues structure and 'exact shot version' hints at source_version, but project_root, shot_id, and request_id are entirely unexplained, and the cue object shape is not documented.

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 (apply), resource (frame/value mouth cues), and scope (an exact shot version), which separates it from the broader animate_shot and add_secondary_motion siblings. It never names those siblings explicitly, so the differentiation is inferable rather than stated.

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

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

There is no statement of when to use this instead of animate_shot or add_secondary_motion, nor any prerequisite guidance such as requiring an assembled shot or a built face rig. Usage is only implied by the phrase 'mouth cues'.

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 implies a read-only integrity check, but says nothing about what validation failure looks like, whether it mutates state, what permissions are required, or how the hash comparison is performed.

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 it may be under-specified rather than genuinely 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 described. For a three-parameter, all-required validation tool with no annotations, however, the description leaves the agent without enough to invoke it confidently — the parameters and failure semantics 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?

All three parameters (project_root, character_id, version) have 0% schema description coverage, so the description is the only place semantics could be added — yet it names none of them. 'Exact character lineage' faintly gestures at the version/id pairing but gives no format or constraint 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?

States a specific verb pair (read and validate) plus the resource (character lineage and recorded artifact hashes), which is distinct from every sibling — none of the other tools validate anything. It stops short of explicitly differentiating itself from inspect_project or inspect_asset, but the intent is legible.

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 call this versus inspecting an asset or comparing versions, and no prerequisites. The agent must infer that this is the integrity-check entry point rather than a general inspection tool.

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