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

Adds context beyond the annotations: dry-run by default (apply=false), the generation must be an immutable plan.json reference, source Actions are retained (non-destructive), and unsupported adapters fail with concrete errors. These are useful behavioral disclosures the readOnly/destructive hints alone do not convey.

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?

Dense but front-loaded around the plan-then-apply workflow. Some clauses, notably "high-level M6 unit" and "technical QA and temporal artistic review are distinct," cost space without giving an agent an actionable instruction.

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 mutation default is covered. Still, for a 7-parameter optional-everything mutation tool the description leaves the core effect of "accept" and four parameters undefined, which is not fully adequate.

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

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

Schema coverage is 0%, so every parameter depends on the description, and it only explains apply, generation, and options; brief, intent, object_name, and operation_id are unmentioned. The partial explanations it does give (plan.json reference, options carrying stage thresholds/visual review) are substantive but leave half the surface 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 never plainly says what "accept" does to a generated animation (finalize, commit, mark approved?) — it opens with the opaque phrase "high-level M6 unit." Nothing distinguishes it from sibling animation_reject_generated, which is the natural alternative an agent must choose between.

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?

"Plan first, apply=false by default" and "Explicit mapping and compatible body rig required" give real preconditions and a two-step workflow. However, it never names reject_generated or states when acceptance is appropriate versus rejection, so the routing to a sibling is left implicit.

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

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

Annotations already declare it as a non-destructive mutation, but the description adds significant context: the plan/apply split, default apply=false, the immutable plan.json reference, retention of source actions, separation of technical QA and artistic review, and error behavior for unsupported adapters. This goes well beyond the structured fields, though some phrasing is jargon-heavy.

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 dense paragraph with no clear front-loading; the opening phrase "high-level M6 unit" wastes space. It packs useful information but is not structured for quick scanning, mixing purpose, workflow, and error handling without clear separation.

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

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

Given the tool's complexity (7 optional parameters, mutation) and the presence of an output schema, the description covers workflow and error handling but leaves four parameters unexplained. It also lacks sibling differentiation, leaving an agent to infer where this fits among many animation generation and refinement tools.

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

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

Schema description coverage is 0%, so the description must compensate for all seven parameters. It only adds meaning for three (apply, generation, options) and leaves brief, intent, object_name, and operation_id 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 restates the tool name ("animation_add_follow_through: high-level M6 unit") without clarifying what the tool actually does in plain terms. It mentions planning and applying, but the core action (adding follow-through to an animation) is only inferred from the name; no specific verb+resource distinction from siblings is provided.

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 a two-step workflow ("Plan first, apply=false by default") and lists prerequisites ("explicit mapping and compatible body rig required"), giving some usage context. However, it does not name alternatives or specify when to avoid this tool versus related siblings like animation_add_overlap or animation_refine_generated.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and the description is consistent: 'Source Actions retained' and 'generation is the immutable plan.json reference' explain the non-destructive staged model. 'Unsupported adapters return concrete errors' adds error behavior. But the plan-vs-apply workflow and what 'apply' mutates is only hinted at.

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 text is short but dense with unexplained jargon ('high-level M6 unit', 'declared stage parameters') and semicolon-chained clauses, so it is terse without being informative. The plan-first rule is not front-loaded and competes with decorative phrasing.

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

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

An output schema exists, so return values need not be described. But for a staged, non-idempotent mutation with 7 undocumented parameters and a prerequisite rig/mapping, the description omits what overlap does, what it produces, and how the plan/apply cycle proceeds — too much is missing to call this 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% across 7 parameters, so the description must carry the burden. It mentions apply, generation, and options ('declared stage parameters, thresholds or visual review'), but brief, intent, object_name, and operation_id are entirely unaddressed. Partial compensation leaves significant gaps.

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

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

The description essentially restates the name: "animation_add_overlap: high-level M6 unit". It never explains what 'overlap' means operationally or how it differs from close siblings like animation_add_follow_through, animation_refine_generated, or animation_polish_curves. 'High-level M6 unit' is unexplained jargon that adds no clarity.

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

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

"Plan first, apply=false by default" gives a clear sequencing rule, and "explicit mapping and compatible body rig required" states a prerequisite. However, it never routes the agent against alternatives (e.g., when to use add_overlap vs add_follow_through or the generate/refine chain), so selection guidance is implied at best.

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

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

Annotations already declare the mutation profile (readOnly=false, destructive=false, idempotent=false). The description adds real value on top: source actions are retained, generation acts as an immutable plan.json reference, and unsupported adapters return concrete errors. It still does not say what is actually modified in the scene or whether apply=false writes anything at all.

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

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

Front-loading is squandered on a restatement of the tool name, and terms like "M6 unit" and "temporal artistic review" are undefined internal jargon that consume space without informing an agent. The sentences are terse but opaque rather than efficient.

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

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

For a 7-parameter, zero-coverage schema with no required fields, the description leaves most inputs unaddressed; the existence of an output schema covers return values, but the input contract remains largely undocumented. An agent would have to guess at brief, intent, object_name and operation_id semantics.

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, so the description must carry the load. It explains only apply, generation and options in vague terms ("options carries declared stage parameters, thresholds or visual review"), and leaves brief, intent, object_name and operation_id completely undefined.

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 restates the tool name and labels it a "high-level M6 unit" without ever saying what timing adjustment it performs or what it produces. Siblings such as animation_analyze_timing, animation_retime and animation_analyze_fcurves are never differentiated, so an agent cannot tell what makes this the right call.

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?

"Plan first, apply=false by default" gives a useful dry-run convention, but there is no guidance on when to choose this over animation_retime or the analyze_* timing tools. Prerequisites are asserted ("explicit mapping and compatible body rig required") without explaining how to satisfy them.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds some scope detail by mentioning layered actions and warnings, but it does not explain pagination behavior, filtering effects, or what the warnings represent.

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 tightly written sentence with no filler, and it front-loads the core purpose. It is appropriately concise for the information it chooses to include.

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

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

For a tool with four undocumented parameters and many sibling analysis tools, the description is too sparse. It does not explain filtering, pagination, or how the summary is scoped, though the output schema does cover 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?

The schema has four parameters with 0% description coverage, and the description does not mention limit, offset, action_name, or object_name. No parameter meaning is added beyond the bare schema.

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

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

The description states a specific verb, 'Summarize', and concrete resources, 'Actions and F-Curves', including layered actions and warnings. The purpose is clear, but it does not distinguish itself from close siblings such as production.animation_analyze_fcurves.

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 the many other animation analysis tools, nor any prerequisites or exclusions. The description implies analysis but gives no selection criteria.

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?

Beyond the annotations it discloses real behavior: dry-run by default, generation treated as an immutable plan reference, source Actions preserved, and unsupported adapters returning concrete errors. These details are consistent with destructiveHint=false and readOnlyHint=false and give the agent a meaningful safety and failure model, though the phrasing is jargon-heavy.

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 short and the workflow constraint is front-loaded, but the opening clause "high-level M6 unit" earns nothing and the remaining sentences compress several distinct ideas (workflow, prerequisites, preservation, review stages, options, error behavior) into opaque nomenclature.

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 7-parameter, zero-required, mutation-capable tool with an output schema, the description covers the critical decision points: default dry-run, prerequisite rig mapping, source preservation, and error behavior on unsupported adapters. What is missing is coverage of the four undefined input parameters and any statement of what the analysis returns conceptually.

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 carry the load; it explains apply (default false), generation (immutable plan.json reference) and options (declared stage parameters, thresholds, visual review). The remaining four parameters (brief, intent, object_name, operation_id) get no mention at all, leaving roughly half of the surface 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?

"animation_analyze_arcs: high-level M6 unit" essentially restates the name and adds an internal tier label an agent cannot interpret; it never says what an arc analysis actually inspects or produces. The only substantive hints are "technical QA and temporal artistic review are distinct," which gestures at two outputs but does not distinguish this from siblings such as animation_analyze_motion_quality or animation_analyze_spacing.

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?

"Plan first, apply=false by default" gives a usable workflow cue and "Explicit mapping and compatible body rig required" states a prerequisite, which is more than nothing. However, no alternative is named (e.g. animation_refine_arcs for fixes), and there is no statement of when-not to call 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?

The description honestly bounds the heuristic — 'not biomechanics' and 'never auto-corrects' — which complements destructiveHint=false and idempotentHint=true. But it doesn't reconcile the readOnlyHint=false annotation (does it write a report or marker?), leaving the agent unsure about side effects.

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

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

A single dense sentence with no filler, and the key caveats are front-loaded. It is efficient, though the terseness contributes to the semantic gaps elsewhere.

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

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

An output schema exists, so return values needn't be described, and the non-corrective scope is stated. But for a two-parameter tool with a free-form options blob and no annotation clarity on writes, the description is not sufficient 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?

Both parameters have 0% schema description coverage, and 'options' is an untyped anyOf object accepting arbitrary additional properties. The description offers zero guidance on object_name format or what options are valid, so an agent must guess what to pass.

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 phrase 'support-region/pelvis projection heuristic' hints at a balance analysis, and 'never auto-corrects' distinguishes it from the refine sibling, but there's no explicit verb+resource statement like 'analyzes character balance from pelvis projection'. An agent can guess the purpose but must infer 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?

'Never auto-corrects' implies this is diagnostic-only and that production.animation_refine_balance is the corrective counterpart, which is useful. However, there is no explicit when-to-use guidance relative to the many other analysis tools (animation_analyze_body_mechanics, animation_analyze_motion_quality).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds no behavioral context — nothing about what region/curves are inspected, what 'finding' means, or what 'handle' entails (the verb 'Handle' is ambiguous and mildly at odds with a pure analysis tool, though not a strict contradiction).

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 short sentence with no padding, which is good, but it front-loads an interpretive caveat rather than the tool's purpose, and the clause is too compressed to be parseable without the tool name.

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

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

An output schema exists, so return values need not be described. However, for a two-parameter tool with 0% schema coverage and a cryptic, purpose-free description, an agent cannot reliably decide when to call it or what to pass — the definition is materially incomplete.

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

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

Schema description coverage is 0% for two parameters, including a required 'object_name' string and an untyped 'options' object with additionalProperties. The description supplies zero information about either parameter, so an agent has no basis for constructing the options payload.

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 never states what the tool does. 'Handle overshoot and contextual tangent findings' gestures at a topic (bezier tangent analysis) but uses no verb+resource framing and does not distinguish this from siblings like production.animation_repair_bezier or production.animation_analyze_fcurves. An agent must infer purpose entirely from the tool name.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative tool is named. The clause 'fast motion is not automatically a spike' is a hint about interpreting results, but it does not tell an agent when to call this tool or what to do with the output.

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

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

Annotations declare the mutation profile (readOnly false, destructive false, not idempotent), and the description usefully adds that source Actions are retained, that generation acts as an immutable plan.json reference, and that unsupported adapters return concrete errors. However, it never says what apply=true actually creates or modifies, and the "technical QA vs temporal artistic review" sentence is too cryptic to inform behavior.

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

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

It is compact and front-loads the plan/apply default, but the lead sentence ("high-level M6 unit") is pure jargon that earns no place, and the remaining clauses are dense run-ons that require decoding rather than reading.

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. Still, for a 7-parameter tool with 0% schema description coverage, four parameters are undocumented in both places, and the caller is left without a concrete statement of what this analysis step yields or how it differs from the neighboring analysis tools.

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

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

Schema coverage is 0%, so the description must compensate and only partially does: it explains apply (default false, plan-first), generation (immutable plan.json reference) and loosely options ("declared stage parameters, thresholds or visual review"). brief, intent, object_name and operation_id — four of seven parameters — get no semantic treatment at all.

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 never states what the tool actually analyzes or produces; "high-level M6 unit" is internal jargon that conveys nothing to an agent. It gestures at a plan/apply workflow, but the resource and the meaning of "body mechanics" analysis are left to inference from the name alone. No sibling (animation_analyze, animation_analyze_balance, animation_analyze_motion_quality) is differentiated.

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

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

"Plan first, apply=false by default" plus "Explicit mapping and compatible body rig required" give a real ordering rule and prerequisites, which is more than most. But there is no guidance on when to choose this over the many adjacent analyze_* tools, and no exclusion criteria.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the agent knows it is a non-destructive, idempotent operation that may write. The description adds schema-mode context and mentions configurable thresholds, but does not clarify what is written or what side effects occur. With annotations covering the safety profile, a 3 is appropriate.

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

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

The description is short but poorly structured: it opens with schema jargon rather than a clear action, and the second and third clauses are fragments. It is concise, but front-loading and readability suffer.

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 explain return values. However, for a two-parameter analysis tool with nested options, it should say more about object_name and option structure. It covers the mode distinction but not enough input context.

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

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

Schema description coverage is 0%, so the description must compensate. It only alludes to a 'schema' field and configurable thresholds inside options, and never explains object_name or the options structure. This leaves both parameters largely 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 states the resource (phase contacts) and the two supported schema modes, ground-plane M2 and explicit feet+surfaces M3. It is specific enough to distinguish the tool from generic sibling analysis tools, but it does not name an alternative sibling and is jargon-heavy.

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?

It explains that the 'schema' field selects between M2 and M3 modes, which is a usage cue for the options object. However, it gives no guidance on when to choose this tool over siblings such as animation_detect_contact_surface or animation_analyze_foot_phase, and 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the trailing 'no mutation' merely restates the structured safety profile rather than adding to it. The description says nothing about what the analysis reports, its scope relative to the rig, or cost/latency characteristics, so it contributes almost no behavioral value beyond annotations.

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

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

It is a single compact clause with no filler, and the read-only constraint is placed at the end. Brevity here tips into under-specification: the density of undefined jargon ('M2', 'M3') means the short sentence conveys less than a longer clear one would.

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 narrated, but the tool takes a free-form options object with zero documentation and an unexplained object_name, and the M2/M3 terminology is undefined. For a diagnostic tool embedded in a large rig/animation tool family, the description is not sufficient 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 coverage is 0%: object_name has no description and options is a free-form object with default null and no documented shape. The description never references either parameter, so the meaning of 'options' (what control-mode settings can be passed?) is left entirely unexplained, which is the exact gap a description should fill at low coverage.

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

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

The fragment identifies the subject as control-mode analysis covering per-limb modes, targets, switches and driver relationships, which is a real resource. However, the opaque tokens 'M2' and 'M3' are never defined, so an agent cannot tell what is actually being analyzed or how this differs from neighbors like rig_analyze_controls or rig_analyze_limbs.

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 reach for this tool versus rig_analyze_controls, rig_analyze_limbs, or animation_analyze. 'No mutation' implies a read-only diagnostic, but no preconditions, triggering scenarios, or alternatives are named.

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

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

Annotations already declare non-destructive, idempotent behavior, so the description's main added context is that results are estimates and that proximity alone is insufficient. It does not explain assumptions, limitations, or how dwell/contact/sliding/penetration are determined, and it does not address what the readOnlyHint=false annotation implies for a tool described as analysis.

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. However, it reads as a cryptic fragment and is too terse to be structurally helpful for an agent.

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

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

Given that this is an analysis tool with an output schema but undocumented input parameters, the description should clarify object_name and options usage and its relationship to sibling contact-analysis tools. None of that is provided.

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

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

Schema description coverage is 0% and the description explains neither the required object_name parameter nor the options parameter. For a two-parameter tool with no schema documentation, the description must compensate but provides no parameter meaning at all.

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

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

The description states the tool produces estimates for effector dwell/contact/sliding/penetration, which is a specific analysis resource. However, 'Generic' is undefined and it does not clearly distinguish this tool from siblings such as animation_analyze_contacts or animation_detect_contact_surface. The phrase 'proximity alone is insufficient' hints at scope but remains 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?

There is no guidance on when to use this tool versus animation_analyze_contacts, animation_detect_contact_surface, animation_detect_foot_sliding, or animation_generate_effector_contact. The note that proximity alone is insufficient is a constraint or caution, not a routing 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds that filtering supports bone/channel/frame/severity/detail and native-unit thresholds, which is useful behavioral context, but it does not explain what 'contextual findings' means or what categories of issues are reported.

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

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

It is a single compact sentence with no filler. The front-loading is acceptable, though the leading adjective 'Contextual' is vague rather than informative.

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 read-only analysis tool in a crowded animation family with 0% parameter coverage, the description is too thin: it does not say what the analysis detects, how filters map to options, or how it relates to overlapping siblings.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It partially does by naming filter dimensions (bone, channel, frame, severity, detail) and native-unit thresholds, presumably within the opaque 'options' object. However, object_name is not described at all, and no value types, ranges, or syntax are provided for the filters.

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

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

The description is essentially a restatement of the tool name plus a filter list: 'Contextual F-Curve findings' does not state a clear action or what kind of analysis is performed on the F-Curves. It gives no differentiation from siblings like animation_analyze, animation_analyze_bezier, or animation_cleanup_fcurves.

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, no exclusions, and no reference to the many sibling analysis tools. An agent must infer its role entirely from the name and the filter list.

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

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

Annotations already declare readOnly=false, idempotent=true, destructive=false, and openWorld=false. The description adds only that the method uses geometric heuristics and physical metrics, without explaining what gets read or written, what surfaces are considered 'explicit static,' or what the output represents despite an output schema existing.

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

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

The description is a single concise fragment with no wasted words, but its structure is cryptic and under-specified for a complex analysis tool. It front-loads the phases concept but leaves the reader to infer the action being performed.

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

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

For a tool with two undocumented parameters, zero schema description coverage, and a complex animation-analysis purpose, the description is far too sparse. Even though an output schema exists, the agent lacks enough context to know what inputs mean or when this analysis is appropriate.

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 carry parameter meaning, but it does not explain object_name or the options object. The phrase 'explicit static surfaces' faintly hints that options may involve surface definitions, but this is not actionable for the agent.

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

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

The description identifies the analysis target (heel/sole/toe phases against explicit static surfaces) but uses a noun-phrase fragment rather than a clear verb+resource statement. It partially distinguishes the tool from general contact analysis by mentioning static surfaces, but it does not explicitly differentiate it from siblings like animation_analyze_contacts or animation_detect_contact_surface.

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

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

There is no guidance on when to use this tool versus alternatives such as animation_analyze_contacts, animation_analyze_effector_contact, or animation_detect_foot_sliding. The description provides no exclusions, prerequisites, or context for selecting this analysis.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, which is the surprising part here (an 'analyze' tool that is not read-only), and the description does not explain why — no mention of an artifact, cache, or report being written. What it does add is a genuine scoping disclosure ('No artistic quality score') and the schema-versioning behavior of the response, both of which are useful and not in the structured fields.

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 dense sentence plus a short negative clause — no filler, and the metric list is front-loaded. The density of schema identifiers (production.motion_quality.rig.v1 / limb_chains.v1) makes it slower to parse than it needs to be, but nothing 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 the input side is unaddressed: a free-form `options` object with zero documented coverage governs which of the two analysis shapes is produced. Combined with an unexplained readOnlyHint=false on an analysis tool, an agent cannot complete the picture from this definition.

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 and largely does not: `object_name` is never explained, and `options` is a free-form object with `additionalProperties: true` that is a black box in both schema and description. The description hints that whole-rig vs limb-chain mode and a schema identifier exist, but never says that these are selected via `options`, leaving the only meaningful parameter undiscoverable from the text.

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

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

The description names the specific metrics produced (velocity/acceleration/angular/contact indicators) and the two analysis shapes (whole-rig vs explicit limb chains), which distinguishes it from metric siblings like animation_analyze_spacing, animation_analyze_timing, or animation_analyze_arcs. It does not explicitly route against those siblings, but the measurement vocabulary is concrete enough that an agent knows what it gets.

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: it states there are two modes and that the 'schema' field in the result says which was used, so an agent can infer mode selection follows the input. There is no when-to-use statement, no when-not, and no named alternative among the many analyze_* siblings (arcs, spacing, timing, balance, foot_phase) that an agent must choose between.

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

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

Annotations already declare non-readonly, non-destructive, non-idempotent, closed-world. The description adds real context beyond that: a dry-run default, an "explicit mapping and compatible body rig" prerequisite, retained source Actions, and concrete errors from unsupported adapters. However, the phrasing is opaque ("immutable plan.json reference", "M6 unit") so the value is present but hard to act on.

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

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

Four dense, jargon-laden sentences that do not front-load the actual capability; the reader gets "high-level M6 unit" before learning anything about pose silhouette analysis. Tightening is not the issue — the content is compressed yet under-informative.

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 description does cover the dry-run default and rig/mapping prerequisite. Still, key invocation unknowns remain: what brief/intent/object_name accept, and what distinguishes this analysis from the many other animation analyzers.

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 optional parameters, so the description must carry the full burden. It clarifies apply (default false), generation (a plan reference), and options (stage parameters/thresholds/visual review), but leaves brief, intent, object_name, and operation_id 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?

The description never states what the tool actually analyzes: no verb+resource framing beyond the name, only cryptic taxonomy ("high-level M6 unit") and workflow jargon. "Silhouette" and "pose" appear only in the name, so the description largely restates the title rather than defining the operation. It also fails to distinguish itself from close siblings like animation_analyze_pose or animation_validate_pose.

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?

"Plan first, apply=false by default" implies a preview-then-apply workflow, which is genuine usage guidance, but no alternative tools are named and no when-not-to-use condition is given. With dozens of sibling animation analyzers (pose, arcs, timing, balance, motion quality), the absence of routing guidance is a real gap.

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

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

Annotations declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, but the description does not explain what non-read-only effect an analysis tool has, whether it writes caches/results, or what conditions affect behavior. It adds some domain context (world-space metrics, derivative events) but leaves the behavioral profile 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?

The definition is only one terse fragment with a semicolon list. It is concise in length but under-specified rather than efficient: the core action and output are not front-loaded, and the meaning of 'hierarchy-based root candidates' is unclear.

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

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

Although an output schema exists, the description does not compensate for 0% parameter documentation, provide usage context, or clarify the non-read-only annotation. For a tool with two parameters and a required object_name, this is materially incomplete.

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

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

Schema description coverage is 0%, and the description does not mention the required object_name parameter or explain what the free-form options object controls. With both parameters undocumented in schema and description, the agent has no semantic guidance for invocation.

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

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

The description names the analysis domain (root candidates, world-space distance/displacement/rotation, derivative events), which is more specific than the tool name alone. However, it is a verbless noun-phrase fragment and does not clearly state what the tool produces or how it differs from siblings like animation_prepare_root_motion or animation_generate_root_motion.

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 alternative tools such as animation_analyze, animation_prepare_root_motion, or animation_generate_root_motion. The agent must infer entirely from the name and fragmentary description.

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

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

Beyond the annotations (readOnly=false, destructive=false, idempotent=false), it discloses meaningful conduct: dry-run by default via apply=false, the generation artifact is an immutable plan.json reference, source Actions are retained, and unsupported adapters return concrete errors rather than failing silently. That is substantive behavioral context an agent could not get from structured fields alone.

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 compact, but the opening 'high-level M6 unit' is internal shorthand that spends prime front-loaded space without telling the agent what the tool does. Several clauses ('temporal artistic review are distinct', 'declared stage parameters') are dense yet low-information for a caller.

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 shape need not be described, and the description does cover the plan-then-apply workflow and prerequisites. Still, for a 7-parameter, zero-coverage analysis tool in a dense sibling family, the missing per-parameter guidance and missing differentiation from other animation_analyze_* tools leave the definition only minimally 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% across 7 parameters, so the description must compensate. It partially does: apply's default-dry-run meaning, generation as an immutable plan.json reference, and options as the carrier for stage parameters, thresholds, or visual review. brief, intent, object_name, and operation_id go entirely unexplained, leaving half the surface 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 name and phrase 'high-level M6 unit' plus 'Plan first, apply=false by default' imply an analysis stage that emits a plan, but the description never states what 'spacing' analysis actually computes or returns. Internal jargon like 'M6 unit' and 'declared stage parameters' obscures rather than clarifies, and nothing distinguishes it from siblings such as animation_analyze_timing, animation_analyze_arcs, or animation_analyze_bezier.

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?

It gives real entry conditions: plan first, apply defaults to false, and 'explicit mapping and compatible body rig required'. However it never says when to reach for this tool versus the other spacing/timing analysis siblings, so the agent must infer the choice 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?

Beyond the annotations it discloses that execution is non-mutating unless apply=true, that the generation is an immutable plan.json reference, that source Actions are retained, and that unsupported adapters return concrete errors. That is meaningful behavioral context for a potentially mutating tool; only the plan.json mechanics stay 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?

It is short and the apply-default caveat is reasonably front-loaded, but the telegraphic, jargon-heavy phrasing ('high-level M6 unit', 'options carries declared stage parameters') costs readability without adding 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?

An output schema exists, so return values need not be described, and the mutation/planning semantics and prerequisites are covered. But with seven parameters at 0% schema coverage, the description leaves too many inputs unexplained for a tool of this 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%, so the description must carry all parameter meaning, and it only covers apply, generation, and options (stage parameters, thresholds, visual review). brief, intent, object_name, and operation_id are completely undocumented, leaving over half the parameters unexplained.

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

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

The name and the mentions of 'temporal artistic review' versus 'technical QA' imply a timing-analysis pass, but the description never states in plain terms what is analyzed or produced. 'High-level M6 unit' is internal jargon that adds no meaning, so the agent must infer the purpose largely from the tool name.

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

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

'Plan first, apply=false by default' gives real ordering guidance, and 'explicit mapping and compatible body rig required' states a prerequisite. However, no alternative among the many timing siblings (animation_analyze_spacing, animation_adjust_timing, animation_analyze_fcurves) is named, so when to prefer this tool over them is left to inference.

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

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

Annotations declare a non-read-only, non-destructive, non-idempotent write. The description adds meaningful context beyond that: "proposal-first" and "conservative" signal that changes are proposed rather than applied immediately, and "per-channel tolerances" hints at a verification gate. It still omits permissions, whether proposals persist, and what the proposal output 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?

It is a single front-loaded sentence with no filler, but terseness comes at the cost of clarity: "key cleanup on duplicate" is dense and ambiguous rather than genuinely efficient.

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

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

For a 5-parameter mutation tool with 0% schema coverage and an analyze/apply mode switch, the description is too thin. The output schema exists so return values needn't be covered, but the mode semantics and parameter roles are unexplained, leaving an agent unable 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 coverage is 0% across 5 parameters, so the description must carry the load, but it never explains mode (default "analyze"), options, operation, object_name, or operation_id. Only a vague nod to "per-channel tolerances" might map to options, leaving four parameters undocumented anywhere.

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 an action ("key cleanup on duplicate") but "duplicate" is ambiguous and it never states it operates on F-curves directly, relying on the tool name. It is not clearly distinguishable from siblings like animation_polish_curves, animation_repair_bezier, or animation_analyze_fcurves.

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?

"Conservative proposal-first" implies this proposes rather than applies changes, but there is no explicit when-to-use vs when-not-to-use guidance and no named alternative among the many curve-editing 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?

Annotations already disclose the safety profile (non-destructive, idempotent). The description usefully adds that the tool 'restores assignment and frame', clarifying the temporary side effect despite readOnlyHint=false. It does not cover required preconditions or limits of the comparison.

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 compact sentence with the core operation front-loaded and the state-restoration note appended. No filler, though the density makes it harder to parse.

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

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

An output schema exists, so return values needn't be documented. However, with zero schema description coverage and no usage guidance, the description leaves meaningful gaps for a 5-parameter comparison 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% across 5 params. The description never explains what object_name, before_action, after_action, or the frame range mean or how they interact, leaving even the required inputs under-specified beyond their self-evident titles.

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 ('compare') and specific resources ('Action fingerprints and evaluated poses'), which clearly differentiates it from generic before/after comparison siblings. The term 'fingerprint' is domain jargon 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?

No indication of when to use this versus siblings like qa_compare_before_after, deformation_compare, or animation_analyze_fcurves. An agent must infer selection 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?

Annotations already state readOnly=false and destructive=false, and the description adds useful behavioral context: collision-safe creation, a checkpoint before creation, and retention of original Actions. However, it does not clarify whether checkpointing is automatic, how dry_run/operation_id affect behavior, or what the mutation actually changes.

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

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

The description is compact and front-loaded, with no filler. It could be slightly clearer about what 'Plan/create' means in practice, but it is appropriately short for a tool whose annotations and output schema carry some of the burden.

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 non-read-only creation tool with five parameters and no schema descriptions, the definition is too sparse. The output schema and annotations reduce the burden, but the description still leaves key parameter semantics and usage guidance undocumented.

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, and the description does not define name, assign, dry_run, object_name, or operation_id. 'Collision-safe' and 'plan/create' weakly hint at name collision and dry-run semantics, but no parameter meaning is actually explained.

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 resource (Action) and a key property (collision-safe), and it mentions checkpointing before creation. It is clear what the tool broadly does, but it does not explicitly distinguish itself from nearby siblings such as animation_duplicate_action, animation_restore_action, or create_checkpoint.

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 comparison to alternatives. The phrase 'checkpoint before creation' implies a prerequisite or safety step, but it is not clear whether this tool performs the checkpoint, whether the caller must use create_checkpoint first, or when to prefer this over duplicate/restore 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?

Annotations already cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the description's job is to add context — and it does add preconditions (rig compatibility, explicit mapping), immutability of the plan reference, and error behavior for unsupported adapters. However, it never explains what apply=true actually does, which is a notable gap given the readOnlyHint=true annotation; an agent cannot tell whether flipping apply mutates scene state.

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

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

The description is short and dense, but the opening clause ('animation_create_brief: high-level M6 unit') earns nothing and several sentences are compressed jargon rather than front-loaded, actionable guidance. Length is acceptable; information density per sentence is poor.

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 six undocumented parameters, zero schema coverage, and no plain statement of workflow or output artifact, the description is not sufficient for an agent to invoke this tool confidently.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it only partially does: apply (default false), generation (plan.json reference) and options (stage parameters/thresholds/visual review) get cursory mentions. Three of six parameters — brief, intent, object_name — are never explained, and even the explained ones lack format or expected content.

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 first clause merely restates the name and adds internal jargon ('high-level M6 unit') that conveys nothing to an outside agent. The remaining clauses gesture at planning plus a 'brief'/'generation' workflow, but never plainly state what artifact is produced or how it differs from siblings such as animation_generation_plan or animation_create_action.

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

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

'Plan first, apply=false by default' implies an ordering but never says when an agent should choose this tool over the many neighboring plan/generate/create tools. Preconditions are hinted ('explicit mapping and compatible body rig required') but there are no exclusions and no named 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?

Annotations declare readOnlyHint=false, idempotent=true and destructive=false, so the agent knows this is a non-destructive but writing operation, yet the description never says what is written (a QA report? a cache?) or where results land. It also leaves the 'supplied contact events' precondition unexplained — whether contact data must be produced beforehand is a crucial behavioral fact.

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 it is front-loaded with an internal prioritization rule ('Prioritize pose extremes, high angular changes...') rather than the tool's purpose, so the most useful information arrives last.

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 the description is still far too thin for a tool whose three parameters are undocumented and whose write side-effects are unstated. It also gives no notion of what 'weighted mesh deformation' evaluation criteria produce, which an agent needs to decide whether to call it at all.

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 supplies no parameter meaning at all: object_name, action_name and the opaque free-form options object are entirely undocumented. The phrase 'supplied contact events' is the only oblique hint that options may carry contact data, which is insufficient for a 3-parameter tool with a schemaless nested object.

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 an evaluation of 'weighted mesh deformation', which hints at a QA/analysis of how a mesh deforms over an animation. But the leading clause about prioritizing pose extremes and contact events reads as implementation detail and never states plainly that this is an animation-deformation QA pass. It also fails to distinguish it from siblings like production.character_deformation_qa, production.deformation_analyze or production.facial_deformation_qa.

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 run this versus deformation_analyze, character_deformation_qa, or animation_analyze_motion_quality. No prerequisites (must an action exist first? must contacts be supplied?) and no exclusions are stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, so safety is covered. The description adds only a faint nuance ('evaluated' mesh, 'explicit local' marker) and says nothing about how evaluation is performed, what is measured, or any limits.

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 short fragment with no waste, and the key concept is front-loaded. However, it is a sentence fragment without a verb, which makes it feel under-specified rather than 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. Still, the tool takes a required object name plus an opaque options bag, and the description explains neither the options contract nor how to interpret 'contact surface' results, leaving the agent short of what is needed 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%: object_name and the free-form options object (additionalProperties: true, anyOf null) are undocumented. The phrase 'explicit local effector marker' hints that a marker is supplied somewhere, presumably in options, but the description never names or structures either parameter.

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

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

The description is a noun phrase, not a sentence with a verb: 'Nearest evaluated static mesh surface at an explicit local effector marker.' It largely restates what the name animation_detect_contact_surface already says, and it never distinguishes itself from close siblings such as animation_analyze_effector_contact, animation_analyze_contacts, or animation_generate_effector_contact.

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 mention of prerequisites, and no routing to any of the many contact/effector analysis siblings. The agent must infer the use case entirely 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?

Annotations already declare idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds one genuinely valuable caveat — that thresholds are configurable rather than universal quality standards — which warns the agent not to treat results as pass/fail. It does not clarify what the tool produces or whether a report is persisted, and 'measure' reads lighter than the readOnlyHint=false annotation suggests.

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?

Two sentences, zero waste, with the measurement claim front-loaded and the interpretive caveat second. Nothing is padded or repeated.

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?

Ten parameters with no descriptions, no exclusions, and no guidance on scoping (frame range, bone subset) make this inadequate; an output schema exists so return values needn't be explained, but the agent still lacks the input semantics and sibling routing needed 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 10 parameters, so the description carries the full burden and largely fails: it never mentions armature (the only required parameter), frame_start/frame_end, bones, or step. The phrase 'thresholds are configurable' gestures at sliding_tolerance_m, contact_height_m and contact_speed_m_s without naming or defining any of them.

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?

Specific verb and resource: 'Measure potential planted-foot drift in meters' tells the agent exactly what quantity is produced. It does not, however, distinguish this tool from close siblings such as animation_fix_foot_sliding, animation_analyze_contacts, or animation_analyze_foot_phase, so sibling differentiation is absent.

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, what prerequisite state is needed (an evaluated armature/action, a selected frame range), or which alternative to pick — notably animation_fix_foot_sliding for remediation or animation_analyze_contacts for contact detection. 'Potential' hints at heuristic results but is not framed as usage guidance.

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

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

Annotations declare readOnlyHint=false, idempotentHint=true and destructiveHint=false, so the description should explain what this non-read-only operation actually does or writes — it says nothing about side effects, permissions, or outputs. The phrase about 'contextual events' hints at computed results but discloses no behavioral trait.

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 short, but the brevity comes from under-specification rather than economy: a single semicolon-joined fragment with no lead sentence stating the action. Nothing is front-loaded because there is no complete statement to front-load.

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 detection tool with a free-form options bag and dozens of sibling analyzers, the definition leaves the agent without enough to decide or configure the call. It is materially incomplete 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% and 'options' is an untyped anyOf object, so the description must carry the burden. It hints at chain types and event types (angle/velocity/acceleration/extension) that presumably map to option keys, but it never documents them explicitly and says nothing at all about the required object_name.

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

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

The description is a noun-phrase fragment ('explicit upper/lower/effector chains; contextual angle/velocity/acceleration/extension events') with no verb, so it never states that the tool detects limb pops. It only vaguely gestures at the analysis dimensions, leaving the actual operation to be inferred from the tool name.

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

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

There is no indication of when to run this, what input state it requires, or how it differs from near-identical siblings such as animation_detect_limb_stretch, animation_analyze_effector_contact, or animation_analyze_fcurves. The agent must guess 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?

Annotations already declare idempotent, non-destructive, closed-world behavior, so the description needn't explain safety. It does add one genuinely useful behavioral fact: intentional stretch is reported separately from unintentional stretch, which affects how results should be read. It does not disclose scope (single limb vs entire rig), tolerance thresholds, or whether 'options' changes behavior.

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

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

A single short sentence with no filler, and the key differentiator (reporting configured intentional stretch separately) is placed at the end where it reads naturally. It is under-specified rather than bloated.

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 required, but for a detection tool with a fully undocumented 'options' parameter the description leaves critical gaps: what scope is analyzed, what thresholds or configuration options exist, and what constitutes a reported issue.

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 2 parameters, so the description carries the full burden and fails it: object_name is never mentioned and the open-ended 'options' blob is completely unexplained (no supported keys, thresholds, or filters). Only the object_name title hints at intent.

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 conveys the mechanism (comparing evaluated bone lengths to rest lengths) and that intentional/configured stretch is reported separately, which is specific to limb-stretch detection. However, the fragmentary passive phrasing ('Evaluated lengths versus rest lengths') never states the verb/resource cleanly and gives no hint of how it differs from near-siblings like animation_detect_limb_pops or animation_analyze_balance.

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 or what to do with the result. The agent must infer that this is a validation pass run before/after retargeting or animation fixes.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so safety is covered. The description adds genuine domain context by explaining the q/-q equivalence that causes flips, but says nothing about scan scope (whole action? selected objects?), how flips are reported, or whether it writes anything. Adequate but thin for a detection tool with four filtering 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?

Two compact clauses, front-loaded with the action verb, and the second clause earns its place by explaining the underlying quaternion semantics. Efficient, though its brevity is close to under-specification rather than optimal density.

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 4 undocumented parameters and no statement of what is scanned or what a 'detected flip' looks like in practice, the definition leaves core operational questions unanswered for a diagnostic tool in a large animation tool family.

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% — limit, offset, action_name and object_name have no documented meaning in the schema, and the description never mentions any parameter or how filtering works. It does not compensate at all, leaving the agent to guess whether action_name/object_name scope the scan.

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 ('Detect') and a precise technical resource ('raw quaternion hemisphere changes'), plus a clarifying note that q and -q are the same orientation. It implicitly contrasts with the sibling animation_fix_quaternion_flips (detect vs. fix), but never names that 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?

There is no explicit when-to-use guidance, no prerequisite or ordering advice, and no pointer to animation_fix_quaternion_flips as the follow-up remediation step. An agent must infer that this belongs in an animation-diagnostic workflow from the tool name alone.

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

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

Annotations already declare a non-destructive, non-idempotent, non-read-only mutation, so safety is partly covered. The description adds real value by disclosing that a checkpoint is taken and an exact original-content check runs, plus the dry-run default — but 'exact original-content check' is vague about whether it verifies or aborts, and no permission or failure behavior is described.

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?

Two compact clauses with the non-overwrite guarantee front-loaded and the dry-run instruction last. The telegraphic fragment style ('checkpoint and exact original-content check') is dense but slightly cryptic.

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?

It is a 6-parameter mutation tool with zero schema descriptions, and only one parameter's semantics are addressed. The output schema covers return values, but an agent still cannot tell what action_name versus name should contain or what assign 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 carries the full burden, yet it explains only dry_run's effect. The critical parameters — action_name (source), name (new name), assign, object_name, and operation_id — are entirely undocumented anywhere.

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 verb 'Duplicate' is specific and the 'without overwriting' clause adds a meaningful scoping constraint that distinguishes this from a plain copy. However, the resource is only inferable from the tool name (animation action), and it never explicitly contrasts itself with close siblings like animation_create_action or animation_restore_action.

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

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

It gives one concrete operational instruction, 'Set dry_run=false to create,' which tells the agent that the default call is a no-op preview. It does not say when to duplicate versus create a fresh action or restore a checkpoint, so the choice among siblings remains implied.

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

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

Annotations already declare non-read-only, non-destructive, non-idempotent. The description adds the meaningful idea that mutations require an 'immutable operation' and confirmed contacts, but both terms are undefined and no permission model, reversibility, or revert semantics are described beyond the bare word 'revert'. Cryptic shorthand rather than actionable disclosure.

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 short and the mode sequence is front-loaded, so nothing is padded. However, the telegraphic slash-list and undefined jargon make it dense to the point of being unparseable, which is under-specification rather than effective concision.

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 a five-parameter mutation tool with no required fields, no enums, and 0% schema coverage needs far more than this. Critical gaps remain around what 'options', 'object_name', and 'operation_id' accept and how modes chain together.

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% for five parameters, so the description must compensate and largely fails. The mode list loosely maps to the 'mode' parameter, and 'operation'/'confirm_contacts' hint at the operation field and options payload, but object_name and operation_id are entirely unexplained and no formats are given.

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 lists a lifecycle of modes ('Analyze/propose/preview/apply/verify/revert') but never states the resource being acted on, i.e. foot sliding. An agent must infer the actual purpose from the tool name alone, and nothing distinguishes it from animation_detect_foot_sliding or animation_generate_foot_contacts.

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-to-use guidance. The mode list hints at a workflow order, but it never says to run detect_foot_sliding first, or when to choose fix vs. generate_foot_contacts. The prerequisite phrase 'reviewed controls' is unexplained.

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

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

Annotations already establish that the tool is mutating but not destructive. The description usefully adds that the correction happens on a duplicate and that changed orientation paths beyond tolerance are rejected, but it does not clarify permissions, failure behavior, or what exactly is modified.

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 wording. It is concise, though the phrase about changed orientation paths beyond tolerance is compact to the point of being somewhat opaque.

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

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

The presence of an output schema means return values need not be described, and annotations cover basic safety traits. However, for a tool with five completely undocumented parameters, the description is too sparse to explain how to invoke it correctly or what each parameter controls.

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 five parameters have 0% schema description coverage, and the description does not explain any of them. Terms like mode, options, operation, object_name, and operation_id are left entirely undocumented, making correct invocation difficult.

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: correcting quaternion representation on a duplicate, with a rejection condition for changed orientation paths beyond tolerance. It distinguishes the action from the sibling detection tool by implying a fix rather than an analysis, though it does not explicitly name the alternative.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as animation_detect_quaternion_flips or animation_duplicate_action. The rejection condition describes behavior, not selection criteria, so the agent must infer the intended workflow.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and non-idempotency; the description adds that the default is a non-mutating plan-only pass and that unsupported adapters error out, which is genuinely useful. It doesn't say what apply=true destroys or overwrites, and 'generation is the immutable plan.json reference' is too vague to act on.

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 run-on paragraph front-loads a cryptic label ('high-level M6 unit') and crams unrelated clauses together. 'Technical QA and temporal artistic review are distinct' is tangential to selecting or calling this tool and should be cut or moved.

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 covered, but for a 7-parameter orchestration tool with 0% schema coverage the description is far too thin. It leaves the agent without the semantics of most inputs or a clear picture of the plan-then-apply workflow.

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

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

Schema coverage is 0% across 7 parameters, so the description carries the burden, but it only hints at apply (default false) and options ('declared stage parameters, thresholds or visual review'). Brief, intent, generation, object_name and operation_id are not explained anywhere, leaving most of the interface 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 opening 'animation_generate: high-level M6 unit' is opaque jargon, though the following clauses reveal it produces an animation plan and can apply it. It never explicitly distinguishes itself from the ~20 sibling tools such as animation_generate_locomotion or animation_generation_plan, so an agent cannot tell which one is the general-purpose entry point.

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?

'Plan first, apply=false by default' gives an implied workflow and 'Explicit mapping and compatible body rig required' gives a prerequisite. However, it never names an alternative tool (e.g. animation_generation_plan or animation_generate_* variants) or states when this tool should not be used.

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

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

Beyond the annotations (which only declare non-read-only, non-destructive, non-idempotent, closed-world), the description discloses that apply=false defaults to a non-mutating plan, that the generation is an immutable plan.json reference, that Source Actions are retained, that technical QA and artistic review are separate stages, and that unsupported adapters return concrete errors. That is meaningful behavioral context for a mutation tool, though it stops short of describing rollback or permissions.

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 text is dense and front-loads jargon ('high-level M6 unit') ahead of the useful content, but each subsequent sentence carries concrete information about defaults, prerequisites, and error behavior. It is compact but not cleanly structured for a first-time reader.

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, and annotations cover the safety profile, but the description leaves several parameters undescribed and never plainly states what the tool outputs as an artifact. For a 7-param generation tool with 0% schema coverage, this is adequate but incomplete.

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

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

Schema coverage is 0% on 7 optional params, so the description must compensate. It does explain apply (default false), generation (immutable plan.json reference), and options (declared stage parameters, thresholds, visual review), but leaves brief, intent, object_name, and operation_id entirely undocumented – so it only partially fills 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 name implies generating an attack animation, but the description never plainly states that – it opens with the opaque label 'high-level M6 unit' and speaks of plans, generations, and QA review phases without a clear verb+resource statement. An agent can infer the purpose from the name and the 'generation'/'Source Actions' language, but the description itself does not cleanly declare it or distinguish it from siblings like animation_generate_blocking or animation_generate_hit_reaction.

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?

'Plan first, apply=false by default' gives one concrete sequencing rule, and 'Explicit mapping and compatible body rig required' states a prerequisite. However, it never names the alternative tool (animation_generation_plan) or explains when to prefer attack generation over other animation_generate_* variants, leaving routing guidance implied rather than explicit.

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

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

Beyond the annotations (destructiveHint=false, readOnly=false), the description adds meaningful behavior: apply defaults to false (dry-run/plan mode), the generation reference is an immutable plan.json, source Actions are retained, and unsupported adapters return concrete errors. These are genuinely useful operational facts not captured by the annotations. It stops short of describing what a real apply mutates or its reversibility.

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 front-loads a restatement of the tool name and a cryptic 'M6 unit' phrase before the actionable content. The remaining sentences are dense but each carries some information; the issue is opacity and ordering rather than 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 no explanation, and the description covers the key workflow (plan first, dry-run default), prerequisites, and error behavior. But four of seven parameters are unexplained and the 'M6' framing is undefined, leaving gaps for a mutation-capable tool with no required params.

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 7 params, so the description carries the burden. It does explain apply (default false), generation (immutable plan.json reference), and options (declared stage parameters/thresholds/visual review), but leaves brief, intent, object_name, and operation_id entirely undocumented. Partial compensation for a zero-coverage 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 name implies 'generate blocking animation' and the description hints at a plan-then-generate workflow, but the opening 'high-level M6 unit' is internal jargon that does nothing to explain purpose. It never plainly states what blocking output is produced or how it differs from animation_generate, animation_generation_plan, or animation_validate_blocking. A reader can infer a generation tool but not its distinct 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?

'Plan first, apply=false by default' and 'Explicit mapping and compatible body rig required' give real prerequisites and a workflow ordering. However, no sibling tool is named as the plan step or the validation follow-up ('technical QA and temporal artistic review are distinct' implies tools exist but does not name them). Usage is implied rather than explicitly routed.

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

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

Annotations already declare non-readOnly, non-idempotent, non-destructive, so the description's useful additions are the dry-run default, the immutable plan.json reference, retention of Source Actions, and concrete errors for unsupported adapters. That is real value beyond the schema, but the clauses about 'technical QA and temporal artistic review are distinct' are opaque and add little actionable clarity.

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 text is a run of dense, telegraphic clauses rather than front-loaded prose, and the leading name restatement plus 'M6 unit' consume space without informing the agent. Several fragments ('technical QA and temporal artistic review are distinct') do not earn their place without supporting context.

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

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

An output schema exists so return values need not be explained, but for a 7-parameter mutation-style tool with 0% schema coverage the description leaves too much unsaid: the meaning of most inputs and the concrete plan-then-apply workflow are not spelled out. It is insufficient 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 7 parameters, and the description only glosses 'apply' (default false), 'generation' (immutable plan reference) and partially 'options'. It says nothing about brief, intent, object_name, or operation_id, leaving four parameters undocumented 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?

The description opens by restating the tool name ('animation_generate_breakdowns: high-level M6 unit'), which conveys nothing, then leans on internal jargon ('M6 unit', 'plan.json reference') that does not state in plain terms what a breakdown is or what is produced. An agent can infer it is a generation step with a planning phase, but the actual verb+resource is never spelled out and nothing distinguishes it from siblings like animation_generation_plan or animation_generate.

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?

'Plan first, apply=false by default' plus 'Explicit mapping and compatible body rig required' gives implied usage and a prerequisite, which is more than nothing. However, no sibling alternative is named despite dozens of overlapping generation tools, and there is no statement of when-not to use it or how it relates to animation_generation_plan.

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

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

Annotations already declare the mutating but non-destructive, non-idempotent profile. The description adds useful context: plan-first default, immutable plan.json as the generation reference, source Actions retained, and concrete errors for unsupported adapters. It stops short of explaining reversibility or side effects of apply=true.

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 dense run-on of fragmented clauses with heavy jargon ('high-level M6 unit', 'declared stage parameters') that is not front-loaded around the core action. Several clauses ('technical QA and temporal artistic review are distinct') add little for an invoking agent.

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

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

For a 7-parameter mutation tool with 0% schema description coverage, the description is too abstract. Output schema exists so returns need not be explained, but the inputs, apply semantics, and workflow are under-specified 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 coverage is 0% across 7 params. The description adds meaning for only three (apply default false, generation as plan.json reference, options as stage params/thresholds), leaving brief, intent, object_name, and operation_id 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 largely restates the name ('animation_generate_effector_contact: high-level M6 unit') and adds undefined jargon ('M6 unit'). It never explains what an 'effector contact' animation is or how it differs from close siblings like animation_generate_foot_contacts or animation_detect_contact_surface.

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?

'Plan first, apply=false by default' gives a real workflow precondition, and 'explicit mapping and compatible body rig required' states prerequisites. However, it never names an alternative tool or an explicit when-not-to-use condition, so routing among the many generate_* siblings is left to inference.

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

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

Annotations already establish the safety profile (readOnly=false, destructive=false, non-idempotent, closed-world), so the bar is lower. The description does add real context beyond them: source Actions are retained (confirming non-destructive behavior), the generation is an immutable plan.json reference, and unsupported adapters return concrete errors. However 'technical QA and temporal artistic review are distinct' is cryptic and adds no actionable trait.

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 lead sentence is spent on an internal codename ('high-level M6 unit') rather than the front-loaded statement of purpose the agent needs. Several clauses ('technical QA and temporal artistic review are distinct') are dense terminology that consumes space without transferring 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?

An output schema exists so return values need not be explained, but for a 7-parameter generation tool with zero schema coverage the description leaves core inputs undecided and never plainly states what artifact is produced. An agent would know to plan first and that a rig mapping is required, but not how to populate brief, intent or object_name.

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, so the description carries the full burden and only partly delivers: it explains apply (default false / plan mode), generation (immutable plan.json reference) and options (stage parameters, thresholds, visual review). Four parameters (brief, intent, object_name, operation_id) are never mentioned anywhere, leaving half the surface 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 opens with the opaque label 'high-level M6 unit', which conveys nothing about what the tool produces. The verb 'generate' only appears implicitly via 'generation is the immutable plan.json reference', and nothing contrasts it with close siblings such as animation_generate_effector_contact, animation_analyze_contacts or animation_fix_foot_sliding, so an agent cannot separate it from those without guessing.

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?

'Plan first, apply=false by default' is genuinely useful workflow guidance, and 'Explicit mapping and compatible body rig required' names prerequisites before the call is attempted. What is missing is any routing: no statement of when to choose this over the sibling contact-analysis or effector-contact generation 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and non-idempotent. The description adds useful behavioral details: generation is an immutable plan reference, source Actions are retained, and unsupported adapters return concrete errors. It does not contradict annotations.

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

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

The description is a dense, jargon-heavy block with no clear front-loading of purpose. It repeats the tool name and uses undefined terms like 'M6 unit', adding cognitive load.

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

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

For a tool with seven undocumented parameters and a complex generation workflow, the description is too terse on parameter meaning and selection criteria. It does include some behavioral notes, but overall the agent lacks enough information 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%, so all seven parameters lack schema documentation. The description only sheds light on apply (default false), options (carries stage parameters/thresholds), and generation (immutable reference), leaving brief, intent, object_name, operation_id undefined. Compensation is partial.

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

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

The description opens by restating the tool name and calling it a 'high-level M6 unit', which does not define what a hit reaction generation does. It never states a clear verb+resource, and while it mentions plan-first behavior, the core purpose remains opaque.

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?

It says 'Plan first, apply=false by default' and notes prerequisites ('explicit mapping and compatible body rig required'), giving some implied usage context. But it never names an alternative sibling or states when not to use it.

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

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

Beyond the annotations (which only declare it is a non-readonly, non-destructive, non-idempotent, closed-world mutation), the description discloses the two-phase default, that generation is an immutable plan.json reference, prerequisite rig/mapping requirements, that source actions are retained, and that unsupported adapters error concretely. This is meaningful behavioral context, though the QA-vs-artistic-review clause is 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?

The text is short but front-loads jargon ("high-level M6 unit") instead of the core action, and packs several loosely related clauses into run-on statements. Sentences like "technical QA and temporal artistic review are distinct" do not clearly earn their 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?

An output schema exists, so return values need not be described, and the workflow/prerequisite/error context is present. Still, for a complex 7-parameter generator with 0% schema documentation, the omission of brief/intent/object_name/operation_id leaves gaps an agent needs filled 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 coverage is 0% across 7 parameters, so the description must compensate. It explains apply (two-phase gating), generation (plan.json reference), and options (stage parameters/thresholds/review), but says nothing about brief, intent, object_name, or operation_id, leaving four parameters undocumented anywhere.

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 never plainly states the verb and resource ("generate an idle animation from a brief/plan"); it leans on cryptic labels like "high-level M6 unit" and the tool name itself. An agent can infer idleness generation from the name, but the sentence does not independently establish what the tool does or how it differs from animation_generate or animation_generate_locomotion.

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?

"Plan first, apply=false by default" implies a plan-then-apply workflow, and "Explicit mapping and compatible body rig required" names prerequisites. However, there is no explicit when-to-use guidance against the numerous sibling generators (locomotion, blocking, attack, animation_generation_plan) or statement of when-not to call 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?

Adds real context beyond the weak annotations: apply defaults to false (dry-run), source Actions are retained rather than overwritten, the generation is an immutable plan.json reference, and unsupported adapters return concrete errors. These are substantive safety and failure-mode disclosures. It still does not describe what apply=true actually mutates or how QA/review gates block progress.

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 dense run-on sentence of semicolon-separated fragments, front-loaded with a wasted name restatement and the undefined token 'M6'. Useful facts (dry-run default, rig prerequisite, retained sources) are buried rather than structured, so the reader must parse jargon to extract them.

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

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

The presence of an output schema relieves it of explaining return values, and it does cover workflow order, prerequisites and error behavior. But for a 7-parameter generation tool in a dense sibling family, missing pieces include what locomotion content is produced, the meaning of the brief/intent inputs, and gate conditions for acceptance.

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, so the description carries the full burden. It clarifies apply, generation (immutable plan.json reference) and options (declared stage parameters, thresholds, visual review), but brief, intent, object_name and operation_id are never explained anywhere. Four of seven parameters remain opaque, which is a real gap at this coverage level.

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 name carries the actual meaning (generate locomotion animation); the description opens by repeating it and adds only opaque framing like 'high-level M6 unit'. It never states plainly what artifact is produced (a locomotion action/generation) or how it differs from siblings such as animation_generate_idle or animation_generate. Prerequisites ('explicit mapping and compatible body rig') hint at scope but do not define the operation.

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

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

'Plan first, apply=false by default' implies a plan-then-apply workflow and correctly signals a dry-run default, which is genuine usage guidance. However, it never names the planning sibling (animation_generation_plan / animation_generation_compatibility) or when to move to apply=true, leaving the agent to infer the sequence. No when-not-to-use guidance is given versus the many other animation_generate_* 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?

Annotations already declare a non-readonly, non-idempotent, non-destructive, closed-world operation, and the description adds real context on top: generation is an immutable plan.json reference, source Actions are retained, explicit mapping and a compatible body rig are prerequisites, and unsupported adapters fail with concrete errors. Some phrasing ("technical QA and temporal artistic review are distinct") is opaque, but the safety and prerequisite picture is meaningfully enriched.

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 reasonably short and starts with the tool name, but several clauses ("high-level M6 unit", "technical QA and temporal artistic review are distinct") consume space without informing invocation. The dense, run-on sentence packing makes key constraints harder to extract than they should be.

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 7-parameter generation tool with zero schema coverage and dozens of animation siblings, the description omits parameter meaning, sibling routing, and what the brief/intent inputs are for. The prerequisites and plan-first ordering are the only things that make it callable at all.

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% with 7 parameters, so the description carries the full burden. It only touches three of them vaguely: apply (default false), generation ("immutable plan.json reference"), and options (stage parameters/thresholds/visual review). brief, intent, object_name, and operation_id get no explanation at all.

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?

"high-level M6 unit" is internal jargon that conveys nothing to an agent, and the description never plainly states that it generates a pose. Only the plan-first/apply-default sentence hints at generation, and it does nothing to distinguish this tool from siblings like animation_plan_poses, animation_generate, or animation_validate_pose.

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?

"Plan first, apply=false by default" implies a required ordering and a dry-run-first workflow, which is genuine usage guidance. However, it never names the sibling to call first (animation_generation_plan vs animation_plan_poses) or states when this tool should be chosen over animation_generate or animation_generate_blocking.

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

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

Annotations declare a non-read-only, non-destructive, non-idempotent mutation, and the description adds real context beyond them: apply defaults to false, generation is an immutable plan.json reference, Source Actions are retained, and unsupported adapters return concrete errors. This is useful behavioral disclosure, though the 'technical QA vs. temporal artistic review' line is 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?

Starts by restating the tool name and leads with opaque jargon ('high-level M6 unit'). Sentences are dense and under-explain key terms rather than being genuinely concise; useful facts (apply default, prerequisites, error behavior) are buried mid-stream.

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 annotations cover safety. The description supplies workflow, prerequisites, and mutation semantics, but with 0% parameter coverage and jargon-heavy prose, an agent still lacks enough 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 coverage is 0% across 7 parameters, so the description carries the full burden. It clarifies only apply (default false), options (stage parameters/thresholds/visual review), and loosely generation (plan.json reference); brief, intent, object_name, and operation_id are 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?

The description opens with 'high-level M6 unit', which is internal jargon rather than a statement of what the tool produces. It gestures at 'generation' being an immutable plan.json reference, but never states plainly that it generates/applies root motion curves from a plan, nor distinguishes itself from close siblings like animation_prepare_root_motion or animation_generation_plan.

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?

'Plan first, apply=false by default' implies a workflow and prerequisites ('explicit mapping and compatible body rig required'), which gives some when-to-use guidance. However, no explicit alternative is named (vs. animation_prepare_root_motion or animation_generation_plan) and no when-not conditions 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?

Annotations already declare non-read-only, non-destructive, non-idempotent. Against that, the description adds useful traits: apply=false default means a plan-only dry run, generation references an immutable plan.json, source Actions are retained, and unsupported adapters return concrete errors. The phrasing is dense and vague ('generation is the immutable plan.json reference'), limiting its value.

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

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

It is compact, but the first clause repeats the name, and sentences like 'technical QA and temporal artistic review are distinct' add little for an invoking agent. Dense jargon reduces front-loaded clarity rather than enhancing 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 7-parameter, no-coverage, high-complexity generation tool, the description leaves too much implicit: most parameter meanings, the meaning of 'M6', and how brief/intent/object_name interact are unaddressed. An output schema exists, so return values need not be covered, but the input side remains thin.

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% for 7 parameters, several of which (brief, intent, object_name, operation_id) are never mentioned. The description only sheds light on apply (default false), options ('declared stage parameters, thresholds or visual review'), and obliquely generation, leaving the rest 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 opening 'animation_generate_start_stop: high-level M6 unit' largely restates the name plus an opaque internal tag, without ever plainly stating 'generates a start/stop animation clip.' The reader must infer the resource from the tool name; the description adds prerequisites but not a clear purpose statement.

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?

It gives some real usage context — 'Plan first, apply=false by default' and 'Explicit mapping and compatible body rig required' — which tells the agent prerequisites and the plan-before-apply workflow. It does not, however, distinguish this from closely related siblings like animation_generate, animation_generate_locomotion, or animation_generation_plan.

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

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

Annotations already declare readOnly=false, destructive=false, and idempotent=false. The description adds useful operational context: generation is an immutable plan.json reference, source Actions are retained, and unsupported adapters return concrete errors.

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

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

The description is short but dense with unexplained jargon ('M6 unit', 'temporal artistic review') and semicolon-chained clauses. Some clauses add useful context, but others are opaque and could be reorganized for better front-loading.

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 seven-parameter generation tool with zero schema descriptions, the definition omits meaning for most parameters and adds little about invocation beyond plan/apply and rig prerequisites. The output schema covers return values, but the input side remains 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 coverage is 0% across seven parameters. The description clarifies apply's default, generation as an immutable plan reference, and options as stage parameters/thresholds/visual review, but leaves brief, intent, object_name, and operation_id unexplained.

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

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

The description opens by restating the tool name and calling it a 'high-level M6 unit,' which is internal jargon rather than a clear statement of what a turn animation is. It never explains what 'turn' means or how this differs from sibling generators such as animation_generate or animation_generate_locomotion.

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?

It gives a procedural rule ('Plan first, apply=false by default') and prerequisites ('Explicit mapping and compatible body rig required'), which implies when the tool can run. However, it does not name alternatives or say when to choose this over the many other animation_generate_* 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?

Annotations already declare this is a non-read-only, non-idempotent mutation, so the bar for extra behavioral context is lower. The description adds meaningful traits beyond annotations: default plan mode (apply=false), generation as an immutable plan.json reference, source Actions retained, and unsupported adapters returning concrete errors. These details materially inform safe invocation.

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

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

The single dense sentence is poorly front-loaded: it opens with a meaningless 'high-level M6 unit' rather than the tool's purpose. Semicolon-joined clauses mix purpose, workflow, parameter meaning, and error behavior without clear structure, forcing the agent to parse jargon before reaching actionable information.

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

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

For a 7-parameter mutation tool with 0% schema description coverage, the description should be far more complete. Output schema and annotations cover return values and safety, but the description lacks a clear purpose statement, tool-selection guidance, and documentation for four of seven parameters.

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 7 parameters, so the description must carry parameter meaning. It explains three parameters partially: apply defaults to false (plan mode), generation is the immutable plan.json reference, and options carries stage parameters, thresholds, or visual review. It says nothing about brief, intent, object_name, or operation_id, leaving nearly half the inputs unexplained.

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

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

The description never states a clear verb-and-resource purpose like 'check animation generation compatibility against a rig.' Instead it opens with 'high-level M6 unit,' which is jargon an agent cannot act on, and only implies a compatibility/planning operation through phrases like 'explicit mapping and compatible body rig required.' It does not distinguish this from animation_generation_plan or rig_compatibility_report in plain terms.

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?

It gives one procedural hint ('Plan first, apply=false by default'), but does not say when to use this tool versus the many sibling compatibility and generation tools. Phrases like 'technical QA and temporal artistic review are distinct' suggest a workflow but name no alternatives or selection criteria, leaving the agent to guess.

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