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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one genuinely useful behavioral constraint — inputs must be opaque hex colors (no alpha) — and hints that output is evaluated against text thresholds, but it says nothing about return format, rounding, or which WCAG levels are applied.

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

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

A single front-loaded sentence with no filler; the verb and resource lead. It is arguably too terse for a 4-parameter tool, but nothing in it 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?

With no output schema, the description should convey what comes back and how thresholds are interpreted. It gestures at 'normal/large text thresholds' but omits the WCAG level(s) (AA vs AAA) and the shape of the result, so it is adequate rather than complete for a simple but result-oriented calculator.

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 burden, and it only partially does. It explains the two color inputs ('two opaque hex colors') but does not clarify fontPx or weight, nor how they map onto the 'normal/large text thresholds' it mentions, leaving two of four 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 description names a specific verb and resource: 'Calculate WCAG contrast' for two hex colors, which is clearly distinguishable from siblings like check_accessibility_markup or check_motion_accessibility. It also states the scope (two opaque hex colors, normal/large text thresholds), though it does not explicitly name an alternative tool.

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

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

Usage is only implied: the mention of 'normal/large text thresholds' signals an accessibility-contrast check, but there is no explicit when-to-use, when-not-to-use, or pointer to sibling tools such as check_accessibility_markup. An agent can infer the context but receives no routing 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 already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds that the computation sums by kind and evaluates two explicit budget thresholds, which is useful behavioral context. It stops short of stating what happens when a budget is exceeded or how results 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?

A single front-loaded sentence with the core verb first and zero filler. Every clause carries information about what is summed and what is compared.

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

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

With no output schema, the description carries the burden of explaining the return value, and it does not say whether the result reports per-kind totals, pass/fail against each budget, or overage amounts. Combined with 0% schema description coverage on a nested assets array, the definition leaves gaps an agent must guess at.

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 parameter burden. It implicitly clarifies kind ('by kind'), initialPaths ('initial-load'), and both budget parameters, and 'resource bytes' points at the bytes field. It still leaves the assets object structure and the precise meaning of initialPaths (which paths count toward initial load) 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 states a specific verb+resource pair: sum supplied resource bytes by kind, then compare against initial-load and total budgets. That is far more precise than the bare tool name. It does not, however, explicitly differentiate itself from the many other asset-analysis siblings such as compare_design_assets or validate_asset_manifest.

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. An agent cannot tell from this text whether to reach for this tool or compare_design_assets when a bytes/budget question arises.

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 closed-world, so safety is covered. The description adds only domain framing ('source redistribution') and discloses nothing behavioral: not what the audit checks, what happens when license/noticeIncluded is missing, or whether results are findings versus pass/fail.

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 zero filler, and the object of the audit (versions plus license evidence) is front-loaded. Nothing in the sentence is redundant with the title or annotations.

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 accepting up to 100 dependency records with undocumented nested fields and no output schema, the description should explain what the audit validates and what it returns. It leaves the agent without enough context to prepare inputs correctly or interpret results.

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 single parameter is an array of objects whose fields (name, license, version, noticeIncluded) have no schema descriptions. The description partially compensates by naming 'versions' and 'license evidence', but it omits noticeIncluded entirely and gives no format, defaults, or handling for missing entries.

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 (review/audit) and resource (supplied dependency versions plus recorded license evidence), which is enough for an agent to know this audits dependency licensing. However, it does not distinguish itself from near-siblings like review_licensing or check_media_provenance, so it falls short of a 5.

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

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

No when-to-use statement, no prerequisites, and no alternatives named despite obvious overlap with review_licensing, validate_asset_manifest, and check_media_provenance. The phrase 'for source redistribution' hints at intent 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?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds the useful disclosure that output is expressed in three forms (seconds, frame ranges, normalized progress), which partially compensates for the absent output schema, but it says nothing about determinism, rounding, or how fps affects the result.

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, front-loading the action and the output forms. Nothing is wasted, though the terseness is the root of the ambiguity noted elsewhere.

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

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

For a tool with a nested beats array, three constrained numeric parameters, no output schema, and zero schema descriptions, the description is far too thin. It gestures at output shape but omits duration/fps semantics and the relationship between weights and allocated time.

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 for three parameters. It references 'weighted beats' (mapping loosely to the beats array and weight field), but never explains duration, fps (its default of 30, range 12-120), or the 1-24 beat limit and 100 weight cap enforced by the schema.

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

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

States a specific verb (allocate) and resource (weighted beats) and names the resulting artifacts (seconds, frame ranges, normalized progress). It reads as a distinct build operation versus siblings like validate_motion_spec or build_reduced_motion_plan, though it never explicitly names the timeline object or contrasts with those siblings.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as validate_motion_spec or build_reduced_motion_plan. The agent must infer the workflow position of this tool entirely from its name and the sibling list.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that the output consists of alternatives plus implementation hooks, which is useful context, but it does not describe the shape, format, or limitations of those results.

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 no filler and the output concept front-loaded alongside the input. It is slightly abstract and noun-dense, which costs it the top score.

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

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

With no output schema, the description carries the burden of explaining what callers get back, and 'implementation hooks' is left undefined. Annotations cover the safety profile and the parameter list is trivially small, so it is adequate but not complete for a planning 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%, but the single parameter is a self-documenting enum of motion effect names, so much of the semantics is carried by the vocabulary itself. The description's 'declared effects' maps loosely to the effects array but adds no detail about item limits (1-8) or how each effect is interpreted.

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 'map' plus the resource 'declared effects' and the output ('still/low-motion alternatives and implementation hooks') give a concrete sense of what the tool produces, distinct from check_motion_accessibility or build_motion_timeline. It stops short of naming a sibling to differentiate against, so it lands at 4 rather than 5.

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

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

There is no explicit when-to-use guidance, no prerequisite statement, and no routing to alternatives like check_motion_accessibility or build_motion_timeline. The phrase 'declared effects' implies the input comes from an earlier planning step, but the agent must infer that.

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 closed-world, so the safety profile is covered. The description adds the useful nuance that it works on *source* signals (static markup rather than rendered output) and mentions empty controls, but says nothing about output shape or how findings 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?

One front-loaded sentence with no filler, and the six signal categories are packed into a compact list. It reads slightly like a keyword dump, 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?

For a read-only, single-parameter analyzer with no output schema, the description gives an adequate inventory of what is inspected but omits input expectations (raw HTML string, size limit) and any hint of what the result contains. Adequate but with clear gaps.

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

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

Schema description coverage is 0% and the single parameter (html, max 120000 chars) is undocumented in both schema and description. The description never clarifies that the input is raw HTML to analyze, nor any format/length expectations, so it fails to compensate for the coverage gap.

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

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

The verb+resource is clear once the enumeration is read: it finds accessibility-relevant markup signals (language, title, headings, alt text, labels, empty controls) in HTML source. It is specific about what it looks for, but never differentiates itself from sibling tools such as check_motion_accessibility or inspect_html.

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 the many sibling checks (check_motion_accessibility, analyze_contrast, inspect_html). No prerequisites, no exclusions, no scope guidance beyond the list of signals.

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 a genuinely non-obvious limitation: it only compares evidence the caller supplies and does not verify credential chains, which tells the agent not to trust it as an authenticity proof. It still says nothing about how results are reported or what happens on mismatch.

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

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

A single front-loaded sentence with the verb first and no filler; every clause does work. It is efficient, though the terseness trades away some clarity about inputs and outputs.

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

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

With no output schema and 0% documented subfields across a six-field nested item object, the description leaves significant gaps: what a comparison result contains, how markers factor in, and how many items are expected are all unstated. For an audit-style verification tool this is under-specified.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it only partially does. "Supplied SHA-256 evidence" loosely maps to nativeSha256/distributedSha256 and "provenance requirements" hints at provenanceRequired, but nativeMarkerPresent and distributedMarkerPresent remain entirely opaque, and the expected relationship between the two hashes is never 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 gives a specific verb ("Compare") and specific resources ("supplied SHA-256 evidence and provenance requirements"), so an agent knows this is a provenance/comparison check rather than a fetch or mutation. It does not name or differentiate itself from plausible siblings like validate_asset_manifest or verify_template_source, so it stops short of a 5.

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

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

There is no guidance on when to use this tool versus the sibling verification/validation tools, nor any stated prerequisites or ordering. The only steering is a negative scope disclaimer ("without claiming credential-chain verification"), which is a boundary, not a usage rule.

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

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

Annotations already establish read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description usefully adds that the assessment combines declared motion parameters with supplied markup rather than markup alone, but says nothing about what a finding looks like, thresholds applied, or severity levels.

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 sentence, front-loaded with the verb and resource, with the signal categories packed into a tight list. No filler and nothing redundant with the schema.

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

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

With no output schema, the description should describe what comes back — a pass/fail verdict, a findings list, severities — and it does not. Combined with 0% parameter coverage on a 4-parameter tool, an agent knows roughly what domain this checks but not what it returns or how to interpret the declared-motion inputs.

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 it only partially does: it characterizes the three non-HTML inputs collectively as 'declared motion', which is meaningful framing. It never explains what flashesPerSecond, autonomousSeconds, or hasEquivalentStill mean or what limits they are checked against, leaving the bulk of parameter meaning to infer from bare names, types, and min/max bounds.

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

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

The description gives a specific verb (Review) and a specific resource (declared motion plus supplied HTML) scoped to three concrete signal classes: reduced-motion, pause, and scroll-safety. It is distinguishable from nearby siblings like validate_motion_spec or check_accessibility_markup, though it never names an alternative to sharpen the boundary.

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 implies you call this when you have HTML plus declared motion values needing an accessibility pass, but there is no explicit when-to-use, no prerequisite, and no mention of how it differs from check_accessibility_markup or validate_motion_spec. The agent must infer the routing decision entirely.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds one behavioral signal beyond that — the result includes 'actual token differences' — but with no output schema it says nothing about result shape, ordering, or what happens if an ID is unresolved.

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

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

A single front-loaded sentence with no filler; the count constraint and token-difference payoff are both packed in efficiently. It is terse to the point of omitting useful context, 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?

For a one-parameter read-only comparison tool this covers the basics, and the annotations handle safety. However, with no output schema, the vague hint about 'token differences' leaves the agent without a clear picture of the returned comparison.

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 compensates by stating the 2–5 count range and that the IDs denote bundled assets, but the ID format/pattern constraint and failure behavior for invalid IDs are left 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?

Specific verb (Compare) plus a concrete resource scope (2–5 bundled style/UI/background assets), and it flags that output includes real token differences. It does not name or distinguish itself from the sibling compare_templates, so an agent must infer the asset-vs-template split from wording alone.

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

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

No when-to-use, when-not-use, or prerequisite guidance is given. The only implied context is the implicit comparison use case, and nothing routes the agent between this and compare_templates.

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 closed-world, so the safety profile is fully covered. The description adds only the set of dimensions being compared, which hints at the return content since no output schema exists, but says nothing about ordering, output shape, or error behavior for invalid ids.

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

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

A single front-loaded sentence with a specific verb and scope, no padding or boilerplate. It is close to optimally sized, though the trailing comparison-dimension list is compressed to the point of being slightly ambiguous about output format.

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 read-only, single-parameter tool the description is minimally adequate, and annotations cover the safety profile. However with no output schema the agent gets no sense of what a comparison result looks like, and there is no routing guidance against the near-identical compare_design_assets sibling.

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 one parameter, so the description carries the documentation burden. It does restate the 2–5 cardinality, but that is already encoded in minItems/maxItems, and it gives no explanation of the id format or what happens if an id is unknown, so it adds little beyond the schema.

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

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

States a specific verb (compare) and resource (templates), plus the comparison axes (engine, source media, style, formats) and the 2–5 cardinality, so an agent knows exactly what operation it performs. It does not differentiate itself from the similarly named sibling compare_design_assets, which is the only real gap.

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 alternatives such as compare_design_assets or get_template, and no conditions or prerequisites. The agent must infer entirely from the name that this is the right tool for a multi-template comparison.

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/openWorldHint, so the safety profile is covered. The description adds only the hint that acceptance criteria are produced, without saying what the brief contains, whether anything is persisted, or what the return looks like despite there being no output schema.

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

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

A single front-loaded sentence with no waste, which is good in isolation. For a 7-parameter tool with no schema descriptions and no output schema, the definition is under-sized rather than appropriately sized.

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

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

No output schema exists, so the description should describe the returned brief; it does not. With 7 undocumented-by-description parameters and no usage context, the definition leaves the agent guessing about invocation 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?

Seven parameters with 0% schema description coverage and the description mentions none of them, so it does not compensate for the gap. Field names (subject, lighting, materials, headline, subjectCenterX) are self-explanatory in the schema, but the description clarifies nothing about the medium enum, the subjectCenterX framing range, or how the five required fields interact.

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

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

States a specific verb ('Compose') and resource ('photographic/CG asset brief') and adds the deliverable 'implementation acceptance criteria', so the agent knows what artifact is produced. It does not distinguish itself from siblings like plan_storyboard or plan_visual_qa, which also plan/generate design artifacts.

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, when-not-to-use, or prerequisite guidance, and no alternative sibling is named. The agent must infer the workflow position of a cinematic brief entirely on its own.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint and openWorldHint, so the safety profile is covered without the description. The word 'original' usefully signals fresh generation rather than template reuse, but nothing is said about the output format, determinism, or what the generated document contains. With annotations carrying the safety burden, this is an adequate but thin 3.

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

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

A single front-loaded sentence with no filler; the artifact name comes first and the inputs follow. It is efficient, though arguably thinner than the complexity of a seven-required-parameter generator warrants.

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 generator with seven required parameters, a nested colors object, zero schema descriptions and no output schema, the description leaves an agent without enough to call it confidently. It should at minimum clarify the units/format expected for typeScale and spacing and what the produced DESIGN.md looks like.

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 seven required parameters, so the description carries the full explanatory burden. It loosely maps its enumerated categories onto colors, fontFamilies/typeScale, spacing and componentRules, but never addresses name or purpose, and gives no format detail such as whether typeScale and spacing are pixel values or what a component rule string should look like. Partial compensation only.

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

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

The description gives a specific verb (Create) and a specific artifact (an original DESIGN.md), and enumerates the input categories (colors, typography, spacing, component rules), which implicitly separates it from the single-token generators like generate_palette, generate_type_scale and generate_spacing_scale. It never names a sibling outright, so the differentiation is inferred rather than stated.

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

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

There is no when-to-use guidance, no prerequisite information (e.g., that tokens should be produced first), and no named alternative such as get_design_system or get_template for agents that want an existing design rather than a generated one. The agent must infer the tool's place in the 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 the full safety profile (readOnly, idempotent, non-destructive, not open-world). The description adds useful non-structured context by naming the return artifact type — both shader source and standalone pointer-reactive HTML — which is not captured anywhere else since there is no output schema. It stops short of describing determinism, output size, or how the 'original' generation behaves.

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

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

A single front-loaded sentence with no filler, which is structurally sound. However, it is terse to the point of under-specification for a parameterized generator, so the brevity trades away information rather than demonstrating economy.

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

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

No output schema exists, and the description partially compensates by naming what is returned (shader + HTML). But for a three-parameter generator with zero schema descriptions and an enum-controlled output, the definition is under-specified on how parameters shape the result.

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 three parameters, so the description carries the burden and adds nothing about them. The enum values ('aurora', 'liquid-chrome', 'ripple'), the speed range, and the accent hex format are only discoverable from the raw schema, not from the prose.

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

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

States a specific verb ('Generate') and a precise artifact ('WebGL fragment/vertex shader and standalone pointer-reactive HTML'), which is far more concrete than the name alone. It does not differentiate against any sibling, but no sibling in the set generates shaders, so the risk of confusion is low.

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

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

No guidance on when to reach for this tool versus alternatives (e.g. generate_scroll_scaffold or generate_palette for other generative tasks), and no prerequisites or exclusions are stated. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds useful output context (palette is tonal HSL derived from a single seed, contrast pairs are 'actual opaque' rather than alpha approximations), but it says nothing about the dark/light mode's effect on output or determinism beyond what the idempotent hint implies.

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

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

A single front-loaded sentence that covers both the generation and the contrast-pair computation with no filler. Slightly opaque phrasing ('actual opaque contrast pairs') adds a touch of ambiguity without bloat.

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

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

With no output schema, the description does describe the two outputs (palette and contrast pairs), which is valuable. However, for a tool whose only optional parameter is an unexplained dark/light mode, and which gives no hint of output shape or size, it is only minimally sufficient.

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 burden. It conveys that a single seed color drives generation ('from one seed'), implicitly documenting the required 'seed' parameter, but the optional 'mode' enum (dark/light) is never mentioned and its effect is left unexplained.

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

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

States a specific verb and resource: generate a tonal HSL palette from one seed, plus a secondary computation of opaque contrast pairs. It is clearly distinguishable from siblings like analyze_contrast or generate_type_scale, though it does not name or contrast itself against those siblings.

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

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

The description gives no when-to-use guidance, no exclusions, and never mentions alternatives such as analyze_contrast for standalone contrast checking or get_design_tokens for existing palettes. Usage must be inferred entirely from the verb and 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 readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description usefully signals that output is "original" (generated rather than templated) and container-responsive (container queries, not media queries), but says nothing about return format, determinism across differing inputs, or whether CSS is returned as text or written to a file.

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

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

A single front-loaded sentence with the verb first and no filler. It is tight, though the terseness is partly the reason parameter and usage guidance are absent.

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

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

With no output schema and four undocumented parameters, the description should carry the burden of explaining what is returned and how inputs affect it; it does neither. For a generator tool in a crowded design-tool suite, this leaves real gaps for correct invocation.

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

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

Schema description coverage is 0% and none of the four parameters (gapPx, className, maxWidthPx, minColumnPx) is mentioned in the description. Defaults and min/max bounds exist in the schema, but an agent gets no explanation of how these values shape the generated layout, so the description fails to compensate for the coverage gap.

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

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

States a specific verb ("Generate") and resource ("container-responsive CSS") scoped to an editorial hero and content grid, which separates it from planning-oriented siblings like plan_responsive_crop or generate_scroll_scaffold. It never names an alternative sibling explicitly, so it stops short of a 5.

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

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

The sentence describes the artifact produced but gives no when-to-use condition, no prerequisites, and no routing against siblings such as generate_scroll_scaffold or get_design_tokens. An agent must infer that this is the CSS-generation step rather than being told.

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 the safety profile is covered. The description adds genuinely useful generation-content behavior — the output includes reversible chapter states plus pause and reduced-motion handling, which hints at accessibility compliance. It does not disclose output format, size limits, or whether chapters beyond the schema cap are rejected.

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

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

A single front-loaded sentence, verb-first, with zero filler or restatement of the tool name. It is dense but readable; the only nit is that cramming four distinct feature claims into one clause list slightly blurs the read.

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 generator with four inputs at 0% coverage and no output schema, the description leaves an agent guessing about required fields (title, chapters), the accent format, and the templateId role. Annotations cover safety but nothing about invocation, so the definition is materially incomplete for correct calling.

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

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

Schema description coverage is 0% across four parameters, so the description carries the full burden and fails it. The word 'chapter' faintly gestures at the chapters array, but title, accent, and templateId are never mentioned, and there is no word on the 2-6 chapter bound or the hex accent pattern. Far below the baseline 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?

States a specific verb (Generate) and resource (pinned native-scroll HTML) with a qualifier that this is 'complete original' output, plus feature scope (reversible chapter states, pause, reduced motion). This distinguishes it from generic generate_* siblings like generate_responsive_layout or generate_glsl_shader. It stops short of naming which sibling to prefer when, so it lands at 4 rather than 5.

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

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

The description gives no when-to-use context, no exclusions, and never references an alternative tool despite ~38 siblings. An agent cannot tell from the text whether this precedes build_motion_timeline or replaces generate_responsive_layout. It is purely a statement of what gets produced.

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 safety and repeatability are covered. The description adds that the output is CSS, but the cryptic 'without mixing unitless lengths' does not disclose what is produced, format, or any constraints. With the lower bar set by annotations, 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?

A single front-loaded sentence with no filler. It is efficient, though the terseness leaves gaps that are penalized under other dimensions rather than here.

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 three undocumented parameters at 0% schema coverage and no output schema, the description is far too thin. It never explains unit/density/multipliers or what the generated scale or CSS looks like, so an agent cannot invoke it confidently without guessing.

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

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

Schema description coverage is 0% and three parameters (unit, density, multipliers) exist, so the schema alone leaves meaning unclear. The description hints at 'unitless lengths' but says nothing about density, multiplier arrays, or their defaults/ranges, failing to compensate for the coverage gap.

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

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

States a specific verb+resource: 'Build a consistent spacing rhythm and responsive CSS'. This clearly separates it from generate_type_scale and generate_palette, though it never names those siblings explicitly. Purpose is unambiguous for an agent scanning the tool list.

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

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

There is no when-to-use guidance, no prerequisite, and no named alternative among the many generate_* siblings. The only hint, 'without mixing unitless lengths', is a constraint rather than routing guidance, so the agent must infer usage entirely.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered and the bar is lower. The description adds that the scale is fluid across explicit viewport endpoints, implying interpolated clamp-style output between min/max viewports, but says nothing about output format or determinism beyond the annotation.

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

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

A single front-loaded sentence with no filler; the core action and its main constraint come first. It is arguably too terse for a 6-parameter tool, which is a completeness issue rather than a conciseness one.

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

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

With 6 unlabeled parameters, no output schema, and no annotations describing behavior, the description should clarify what is produced (CSS custom properties, clamp expressions, a token set) and how the viewport endpoints interact. None of that is present, leaving significant gaps for a moderately complex generator.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the full burden and mostly fails: only 'viewport endpoints' loosely points at minViewport/maxViewport, and 'modular type scale' hints at ratio/steps. basePx and desktopMultiplier are left entirely unexplained, and no defaults, ranges, or units are mentioned.

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 (calculate) and resource (modular type scale + fluid CSS), which an agent can distinguish from the sibling generate_spacing_scale and generate_palette. The phrase 'across explicit viewport endpoints' scopes it further, though it never names a sibling to route against.

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 versus generate_spacing_scale, get_design_tokens, or get_design_system, nor any prerequisite or exclusion. The agent must infer usage entirely from the purpose sentence.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive, closed-world, so the safety profile is covered. The description adds one genuinely new behavioral fact — retrieval does not trigger background execution — which is useful, but it says nothing about the shape of the returned workflow, whether results are static/cached, or what happens on an unknown id.

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

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

A single front-loaded sentence with no filler, and the key qualifier comes last as a natural caveat. Slightly dense in its list of payload artifacts, 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?

With no output schema, the description carries the burden of describing the return value; it does gesture at 'deliverables and relevant tools' but omits structure, size, or format. Annotations cover safety, so the main remaining gap is return-shape and enum guidance, making this minimally 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 description coverage is 0% for the single required 'id' parameter; the schema only supplies an enum of six kebab-case specialist names. The description adds no meaning about what these specialists are, how to choose among them, or that the id must be one of the enumerated values.

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

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

States a specific verb+resource (get an agent workflow) and enriches it with the payload contents ('deliverables and relevant tools') plus a scope qualifier ('without starting background execution'). It does not explicitly distinguish itself from the sibling list_agent_workflows, so it stops short of a 5.

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

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

No statement of when to use this versus list_agent_workflows (enumerate all workflows) or the execution-oriented siblings like build_motion_timeline or plan_storyboard. The 'without starting background execution' clause hints at a boundary but is framed as behavior, not selection 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 already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description still adds genuine context beyond them: it clarifies that the tool yields references (URLs and ZIP paths) rather than downloading media, and that assets are "original public" ones.

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

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

One front-loaded sentence with no filler; the scope and the download caveat are both immediately visible.

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?

Annotations carry the safety profile and there is no output schema, so the description is not obligated to explain return values, and it does outline the returned URL/ZIP data. However, it leaves the required id parameter undefined, which is a real gap for a tool with a mandatory identifier.

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

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

The single required parameter "id" has 0% schema description coverage and is completely unaddressed in the description. Nothing explains whether the id is a manifest id, template id, or asset id, so the description fails to compensate for the schema gap.

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

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

States a specific verb ("List") and resource ("asset manifest") and enumerates what is returned: poster/video/font asset URLs plus ZIP paths. Clear enough on its own, but it does not distinguish itself from the very similar sibling get_asset_source, so an agent must guess which to 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?

There is no when-to-use or when-not guidance, and no mention of the closely related siblings get_asset_source, validate_asset_manifest, or check_media_provenance. The clause "no remote media download" hints at a boundary but never states it as 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description does add one useful behavioral fact: the return payload is conditional (bundled source vs. generated CSS variables). However, it never explains what governs which mode is returned, so the disclosure is incomplete.

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

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

A single compact sentence with no filler. It is efficient, though the "or" clause makes the front-loaded promise harder to parse than it needs to 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?

With no output schema, an undocumented id parameter, and an unexplained dual-mode return value, the definition leaves an agent unable to predict what it will receive or how to select the right mode. A conditional-output tool needs that ambiguity resolved in the description.

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

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

There is one required parameter (id) with 0% schema description coverage, and the description says nothing about it beyond the implicit connection to "asset." The constrained id pattern and the distinction between asset ids and token ids are left entirely 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?

It has a verb ("Return") and a resource ("bundled original asset source"), but the second clause ("or explicit CSS variables generated from declared style tokens") describes an entirely different output, leaving the tool's actual purpose ambiguous. It does not clearly distinguish itself from near-siblings such as get_template_source or get_asset_manifest.

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

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

There is no statement of when to use this tool versus get_asset_manifest, get_template_source, get_source_links, or any other sibling. No prerequisites, no context, no exclusions are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The phrase 'bounded user customization' adds some useful behavior context – customization is constrained – but never explains what those bounds are or how they interact with the passed parameters.

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

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

A single tight sentence with no filler, front-loaded on the operation. It is efficient, though perhaps too terse given the complexity of the tool's inputs.

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

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

With no output schema and four parameters at 0% description coverage, the description is the only prose available and it is far too thin. It never explains the id semantics, how brief/headline/accent customize the prompt, or what a returned build prompt looks like.

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 for four parameters and largely fails: it only loosely gestures at 'user customization' without explaining id, brief, accent, or headline. The accent hex pattern and maxLengths are discoverable from the schema, but the meaning and effect of each param is 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 'Return' plus resource 'template build prompt' gives a rough sense of the operation, but 'bounded user customization' is vague and the definition does nothing to distinguish it from the large cluster of sibling template tools (get_template, get_template_source, verify_template_source, etc.). An agent cannot confidently tell when this returns a build prompt versus a stored template.

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 stated alternatives, and no prerequisites for the required id. With ~38 siblings including several template-retrieval tools, the absence of any routing signal 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 already declare readOnlyHint=true, idempotentHint=true, openWorldHint=false and destructiveHint=false, so the safety profile is covered by structured data. The description adds only the notion that output is an 'original' system not drawn from a reference library, which is mildly useful context but discloses nothing about what the returned artifacts contain, their scope, or whether any input is required beyond the id.

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

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

One sentence with the verb front-loaded, so it is compact. But the trailing 'without copying a reference library' clause is a negative behavioral aside that occupies real estate without advancing the reader's understanding of the tool.

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

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

For a single-parameter read tool with rich annotations, the description adequately states what is returned (style system, tokens, DESIGN.md) and no output schema is needed. It is incomplete on the one thing it must carry itself — the meaning of the 'id' parameter — and the audience sits amid many similar-sounding 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% for the single 'id' parameter, so the description is the only place that could explain what the id identifies and where it comes from. It says nothing about the parameter, meaning the agent must guess whether id is a template id, design-system id, or generated identifier.

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

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

The verb 'Get' plus resources (style system, tokens, DESIGN.md) gives a rough sense of a retrieval tool, and the DESIGN.md/tokens mention loosely distinguishes it from get_design_tokens. However, the phrase 'without copying a reference library' is a behavioral constraint rather than a purpose statement and muddles what 'original style system' actually means, leaving the reader to infer the resource.

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 named alternative among the siblings (get_design_tokens, generate_design_document, search_templates). The clause 'without copying a reference library' hints at a constraint but does not tell an agent when this tool is the right choice over lookalikes.

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, and destructiveHint=false, so the safety profile is clear without the description. The description adds that output is viewport-specific and includes CSS variables, which is useful output context, but it does not disclose how style/width/height shape results or what the response contains. Adequate against an already-rich annotation set.

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

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

A single, front-loaded sentence with no wasted words, but its brevity reflects under-specification rather than disciplined conciseness. It packs three output concepts together without clarifying 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?

With no output schema, 0% parameter coverage, and no annotation detail about return values, the description leaves the agent without enough to call the tool confidently. For a generation tool producing tokens and CSS variables, it should at least describe the output shape and how the style parameter selects a design language.

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

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

Schema description coverage is 0% for all three parameters, and the description only loosely implies width/height via 'viewport-specific' and style via 'typography/composition'. The four enum style values (editorial-noir, alpine-product, spatial-tech, automotive) are never explained, so the description fails to compensate for the coverage gap.

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

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

The description names a specific verb and resource set: viewport-specific typography, composition tokens, and CSS variables. However, it does not distinguish this tool from close siblings like get_design_system, generate_type_scale, or generate_spacing_scale, so an agent cannot tell which to pick from the text alone. The name ('get') versus the description ('generate') also creates mild ambiguity about whether it retrieves or creates tokens.

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

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

There is no statement of when to use this tool versus the numerous sibling generators (get_design_system, generate_type_scale, generate_palette). No prerequisites or context for choosing a style are given. Usage must be entirely inferred.

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, and destructiveHint=false, so safety is covered. The description adds that the curve is sampled and that CSS easing is also produced, which is useful output context, but says nothing about determinism, ranges, or what 'plus CSS easing' actually returns.

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

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

A single compact sentence with the core operation front-loaded, so there is no waste. However it is under-specified rather than genuinely concise, cramming jargon without covering the parameters.

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

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

For a tool with an undocumented 4-value enum, an unexplained sampling range, and no output schema, the description leaves too much undefined. It never tells the agent what each intent means or what the two outputs look like, which 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 coverage is 0%, so the description carries the full burden, yet it never mentions the 'intent' enum values (settle, reveal, camera, cut) or the 'samples' count. The cryptic enum labels in particular are left completely undefined, which is a real gap for the one required 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?

States a specific verb ('Calculate') and resource ('sampled cubic-bezier curve'), plus a secondary output ('CSS easing'). An agent can tell this is a computation tool distinct from the manifest/template/audit siblings. It loses a point only because 'time-axis inversion' is unexplained jargon.

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

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

No when-to-use guidance and no mention of any alternative or related sibling (e.g., validate_motion_spec, build_motion_timeline). The agent gets no signal about what context should trigger this tool.

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

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

Annotations already declare this is a safe, idempotent, closed-world read operation, so the description only needs to add context. It contributes the idea that output is derived from a selected template, but says nothing about return shape, permissions, or rate 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, front-loaded sentence with no filler. Every word earns its place and the resource and scope lead.

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

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

For a 2-parameter tool with no output schema and 0% schema coverage, the description is too thin. It leaves undefined what a 'check' comprises, how formats affect output, and why a template must be supplied.

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 burden. It loosely gestures at the formats parameter via 'format-specific' and at the required id via 'selected template', but never explains the id pattern, the enum values (source/mp4/webm/png), the default set, or what selection produces.

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 clear verb ('Return') and a specific resource ('format-specific packaging and playback checks'), scoped to a selected template. It is distinguishable from validation siblings like validate_asset_manifest, though it doesn't explicitly name an 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?

No when-to-use or when-not-to-use guidance and no named alternatives. The phrase 'grounded in a selected template' only hints at a prerequisite (a template id) without stating conditions for selecting this tool over the audit/validation 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 readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral fact beyond that: it operates without touching account data. It says nothing about link format, failures, or auth requirements, so it earns only a middling score.

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

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

A single efficient sentence that front-loads the verb and the returned link types with no filler. Appropriately sized for a simple read tool.

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

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

The description reasonably covers the return payload (source, playground, demo, license links) so no output schema is needed, but it leaves the sole input parameter entirely unexplained. For a one-param tool that gap is the main incompleteness.

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

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

There is one required parameter ('id') with 0% schema description coverage, and the description never explains what the id refers to (template, asset, workflow?) or its expected format. With low coverage the description was expected to compensate and it does not.

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

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

States a specific verb ('Get') and enumerates the resource returned (public source, playground, demo and license links), which is enough for an agent to know what it produces. It does not, however, differentiate itself from lookalike siblings such as get_asset_source or get_template_source.

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

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

The phrase 'without fetching account data' hints at the condition for choosing this lightweight variant, but no alternative tool is named and no when-not guidance is given. Usage is only implicitly conveyed.

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, openWorldHint=false, and destructiveHint=false, so the safety profile is covered. The description adds almost nothing beyond that: 'original' and 'precise media capabilities' are unexplained and do not clarify what is returned or what 'media capabilities' entails.

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 wasted words; it is appropriately sized and front-loaded. The terseness is a virtue for length, though the content itself is thin.

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

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

There is no output schema, one undocumented required parameter, and annotations only cover safety. The description does not explain what the returned 'template' or 'media capabilities' contain, leaving an agent unable to predict the response shape for this lookup 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?

The single 'id' parameter has 0% schema description coverage and the description never mentions it, so an agent learns nothing about what the id refers to (template identifier, slug, etc.). With 1 undocumented parameter, the low-coverage baseline applies and the description fails to compensate.

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

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

The verb+resource (Get ... template) is clear and the word 'one' hints at a single-item fetch, distinguishing it loosely from search_templates and compare_templates. However, 'original template' and 'precise media capabilities' are vague modifiers that leave an agent unsure whether this retrieves template metadata, assets, or generated media specs.

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

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

There is no statement of when to use this tool versus siblings like search_templates, get_template_source, or verify_template_source. No context about prerequisites or when an agent should prefer this over the other template-related tools is provided.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely useful operational context beyond the annotations: an 8-second timeout and a 1MB size limit, which materially affect invocation and failure handling. It stops short of explaining what happens on limit breach or how the origin is resolved.

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 that front-loads the fetched resources and appends the limits compactly; no filler. The phrasing 'the one configured MotionVault origin' is slightly cryptic but does not waste words.

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

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

With no output schema, the description correctly states what is returned (HTML plus asset manifest), and it covers the key operational limits. For a one-parameter read tool with full annotation coverage, the remaining gaps (id semantics, auth/prerequisites, limit-breach behavior) are modest.

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 says nothing about the single 'id' parameter, its slug format, or what entity it identifies. The only hint ('from the one configured MotionVault origin') implies the id resolves against that origin but gives no format or validity detail beyond the raw regex in the schema.

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

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

The description names a specific verb ('Fetch') and precise resources ('complete public standalone HTML and asset manifest'), and states the scope ('from the one configured MotionVault origin'). It does not, however, disambiguate from close siblings like get_template, get_source_links, get_asset_manifest, or verify_template_source.

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 or when-not-to-use guidance, and no sibling is named as an alternative. The phrase 'from the one configured MotionVault origin' implies scope but does not tell the agent when this tool is the right choice over get_template_source-like siblings such as get_template or verify_template_source.

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, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description reinforces this with 'never execute it' (largely redundant) but usefully discloses the inspection outputs (counts, references, duplicate IDs, anchors). It says nothing about output format or 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?

A single front-loaded sentence that lists what is inspected and closes with the key operational constraint. No filler; every clause adds signal.

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

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

For a one-parameter, no-output-schema tool, the description adequately conveys what the input is and what categories of finding to expect. It is nearly complete, missing only edge-case behavior (e.g., malformed HTML handling) and output shape hints.

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 the single 'html' parameter, so the description must carry the burden. It identifies the input as 'HTML source' but gives no format, encoding, or size guidance beyond the schema's maxLength of 120000. Partial compensation for the coverage gap.

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

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

Names a specific verb (inspect) and resource (HTML source), and enumerates concrete checks: structural counts, resource references, duplicate IDs, broken anchors. This distinguishes it from rendering/templating siblings, though it never explicitly names an alternative tool. The 'never execute it' clause sharpens the static-analysis 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?

Usage is only implied: the tool is for static inspection of HTML you supply, contrasted against execution. There is no explicit when-to-use/when-not guidance and no reference to complementary checks like check_accessibility_markup or verify_template_source, which an agent might reasonably confuse it with.

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 readOnly/idempotent/destructive/openWorld, but 'does not spawn agents' adds domain-specific behavioral context that generic hints do not convey — it preempts the wrong assumption that calling this tool initiates agent work. It still says nothing about return ordering or pagination 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 front-loaded sentence with a semicolon-delimited clarification; every clause carries information and there is no padding.

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

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

For a simple no-required-param, read-only list tool with no output schema, the description conveys the count and nature of the returned items plus the no-side-effect guarantee. The undocumented query parameter is the one substantive gap.

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

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

There is one parameter (query) with a 0% schema description coverage, and the description never mentions it — no indication of what the query filters on, whether it is a search term, or that it defaults to empty. A one-param tool at 0% coverage should have its parameter explained in prose, and it does not.

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

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

States a specific verb (discover/list) and resource (six reusable specialist role guides with their tool dependencies), and the count 'six' bounds the result set. It does not name the obvious sibling get_agent_workflow to differentiate single-fetch vs list, so it falls short of the 5 tier.

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 clause 'does not spawn agents' implicitly clarifies when this is safe to call (pure discovery, no side effects), but there is no explicit when-to-use guidance nor a pointer to get_agent_workflow for retrieving a single workflow. Usage is inferable rather than stated.

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

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

Annotations already cover read-only, idempotent, non-destructive and closed-world behavior, so the bar is lower. The description adds a genuinely useful trait not captured by annotations: unverified checks are never upgraded to passes, which tells the agent how missing evidence is handled.

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

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

A single compact sentence with the key constraint front-loaded; nothing is wasted. However, the extreme brevity is closer to under-specification than true economy given the 0% schema coverage.

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

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

With no output schema and no parameter descriptions anywhere, the agent must guess the meaning of the three scope values and the ten gate categories. For a tool whose entire value is a correctly-shaped gate table, the description leaves too much to inference.

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

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

Schema description coverage is 0%, so the description carries the full burden, and it does not explain the scope enum values (preview/public-free/paid-library) or the evidence object shape. "Explicit observed evidence" hints at the input but adds no semantics for the gate/status/note fields the agent must construct.

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

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

The description names a specific verb and artifact ("Build a release gate table") and adds scope qualifiers ("from explicit observed evidence"). It is clear what the tool produces, though it does not distinguish itself from siblings like get_export_checklist or plan_visual_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 explicit when-to-use guidance, no stated prerequisites, and no named alternative. The clause "unknown checks never become passes" is a behavioral rule, not a routing condition, so the agent must infer that this is a pre-release gating tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and a closed world, so the safety profile is covered. The description adds the useful detail that output is a set of numeric crop values rather than a mutated asset, but it says nothing about coordinate conventions, clamping behavior, or what happens when the focus point falls outside the cropped region.

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

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

A single front-loaded sentence with no filler, and the output artifacts are named before the qualifier. It is appropriately terse, though for an 8-parameter tool the brevity edges toward under-specification rather than tightness.

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

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

Eight parameters with zero schema coverage, no output schema, and no nested objects means the description should explain the focus-vs-target coordinate model and the return shape; it does neither. An agent could not confidently map its inputs to the two coordinate systems from this text alone.

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

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

Schema description coverage is 0% across 8 parameters, so the description carries the full burden and largely fails: focusX/focusY (source subject point) versus targetX/targetY (desired output position) are never distinguished, and the defaults 0.7/0.5/0.65/0.5 are unexplained. width/height versus assetWidth/assetHeight semantics are also absent. Only 'desired subject position' loosely gestures at the target parameters.

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

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

The description states a specific verb ('Compute') and enumerates the concrete outputs (object-fit cover scale, crop offsets, object-position) plus the input intent (desired subject position). It is clear what the tool produces, though it never contrasts itself with any sibling; with no near-neighbor in the sibling list, differentiation is not a real risk.

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

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

There is no guidance on when to reach for this tool versus alternatives such as generate_responsive_layout or plan_visual_qa, nor any stated prerequisites (e.g., that you need asset dimensions and target container size). Usage must be inferred entirely from the one-line purpose.

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, non-destructive, closed-world, so the safety profile is covered. The description adds nothing further: it does not explain what a 'mechanism' is, what the four chapters contain, whether output is a persisted asset or an in-memory spec, or how time/frame/progress ranges are derived.

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

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

It is a single front-loaded sentence with no filler, which is structurally fine. However, the brevity reflects under-specification rather than economy, so it earns only a middling score.

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

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

With no output schema, 0% parameter coverage, and a domain-specific vocabulary, the description should carry the explanatory load and does not. An agent cannot determine what the four chapters are, what the return shape looks like, or how to choose a mechanism value.

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

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

Schema description coverage is 0% for all three params, so the description must compensate, and it largely does not. 'mechanism-specific' weakly gestures at the required mechanism enum, and 'time/frame/progress ranges' loosely hints at duration/fps, but the four enum values and the fps values are never mentioned or 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 verb 'Create' and the resource 'storyboard/shots' are present, but the key qualifiers ('mechanism-specific', 'four-chapter') are undefined jargon that an agent cannot map to concrete output. Nothing distinguishes it from siblings like build_motion_timeline or create_cinematic_brief, which also produce timed cinematic planning artifacts.

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 stated prerequisites, and no mention of alternatives among the many related planning tools (build_motion_timeline, create_cinematic_brief, plan_visual_qa). The agent is left to infer the tool's role entirely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds essentially nothing beyond that: no output shape, no note that the result is a plan/artifact, and no explanation of the oddly named 'five-progress' cases.

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

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

It is a single front-loaded sentence with no filler, which is structurally fine. But brevity here tips into under-specification, and the one sentence it spends is partly unintelligible.

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 planning tool with three undocumented parameters, no output schema, and a dense sibling set, the description is far too thin. An agent lacks the input semantics and the expected return 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% for three parameters (id, duration, viewports). The description mentions viewports obliquely but never explains id's slug pattern, duration's default/max, or the viewport array's 1-4 item bounds, so it does not compensate for the coverage gap.

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

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

The description implies creating visual-QA capture cases across viewports, and 'across responsive viewports' gives a usable resource signal. However, the phrase 'exact five-progress capture cases' is garbled and opaque, so an agent cannot confidently state what the tool produces or how it differs from siblings like plan_responsive_crop or compare_design_assets.

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, when-not-to-use, or alternative routing. With ~40 sibling tools including several design/planning neighbors, the absence of any selection guidance leaves 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.

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered by structured data. The description adds only the vague intent 'preserve restrictive source boundaries' and does not explain outputs, what a triage verdict looks like, or how restrictive sources are handled, so it adds modest value beyond the 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 front-loaded sentence with no filler, which is efficient. The terse, jargon-heavy phrasing ('restrictive source boundaries') costs a little clarity, but there is no wasted text.

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 a complex nested input schema and no output schema, the one-sentence description is too thin: it explains neither the required 'use'/'items' contract nor what the review returns. The agent would need the schema alone to call this correctly.

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

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

Schema description coverage is 0% and the 'items' parameter is a nested array of objects with many fields (license, evidence, noticeIncluded, provenancePreserved, redistributionPermission, etc.). The description only loosely gestures at the 'use' enum via 'end-project versus library redistribution' and does nothing to explain the per-item fields, leaving the agent without parameter meaning.

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

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

The description states a specific verb ('triage') and resource ('per-asset evidence') and ties it to the schema's 'end-project versus library redistribution' distinction, so the agent can tell this is a licensing review over assets. It does not explicitly differentiate itself from nearby siblings like check_media_provenance or verify_template_source, keeping it below a 5.

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

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

There is no explicit statement of when to use this tool versus alternatives such as check_media_provenance or verify_template_source. The phrase 'end-project versus library redistribution' hints at the use case but does not give conditions, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and, importantly, openWorldHint=false, so the safety and locality profile is fully covered by structured data. The description adds only the phrase "bounded filters," hinting at capped result sets, and says nothing about default library scoping, pagination behavior, or what a result entry contains.

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

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

A single front-loaded sentence with no filler, and the verb plus resource list leads. The trailing enumeration of library types is slightly run-on but earns its place by mirroring the enum.

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 an 8-parameter, zero-coverage, no-output-schema search tool, the description is thin: it never explains the filter taxonomy, defaults, or how results are ordered/paged. An agent can form a query but cannot use the tool fully correctly without guessing at four 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 description coverage is 0% across 8 parameters, so the description carries the burden and largely does not meet it. It loosely maps "words" to `query`, "bounded filters" to `limit`/`offset`, and echoes the `library` enum values, but leaves `free`, `engine`, `category`, and `mediaKind` entirely unexplained in both the schema and the description.

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

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

The description gives a specific verb ("Search") and enumerates the resource types covered (template, style, background, gradient, UI libraries), which matches the `library` enum and clearly separates it from fetch-style siblings like get_template or verify_template_source. It stops short of naming an alternative or stating scope boundaries, so it is clear but not explicitly 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?

Use is implied — keyword search over a curated asset library with filters — but there is no when-to-use/when-not guidance and no reference to siblings such as get_template, compare_templates, or get_template_source. The agent must infer that this is the discovery entry point rather than the retrieval follow-up.

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, openWorldHint=false and destructiveHint=false, so the safety profile is covered by structured data. The description adds useful content about what is validated, but discloses nothing about return shape, severity/error reporting, or behavior on malformed manifests. With annotations doing the heavy lifting, 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?

A single front-loaded sentence fragment with the verb first and zero waste. It is terse to the point of being a checklist rather than prose, but every clause carries 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 read-only validation tool with no output schema and 0% param coverage, the description is minimally adequate but omits what validation returns (pass/fail, issue list, severity) and any limits such as the 200-asset/400-path caps enforced by the schema. It does not fully carry the burden left by the absent output schema.

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

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

Schema description coverage is 0% across 2 params with nested asset fields (path, url, source, license, sha256, bytes, kind), so the description must compensate. It partly does by mapping to semantic dimensions: 'ZIP-relative paths' (path), 'resource origins' (source/url), 'license gaps' (license), 'supplied packaged files' (packagedPaths). However it gives no formats, constraints, or field-level meaning, leaving 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?

States a specific verb (Check) plus the concrete list of validations performed: ZIP-relative paths, duplicate names, supplied packaged files, resource origins, license gaps. This makes it clearly distinguishable from the retrieval-oriented sibling get_asset_manifest. It stops short of naming an alternative or scope boundary, so it is clear but not sibling-differentiating.

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 routing to alternatives such as review_licensing or check_media_provenance, which overlap with the 'resource origins and license gaps' checks. The description only enumerates what is checked.

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 this as a read-only, idempotent, non-destructive, closed-world operation, so the safety profile is covered without description help. The description adds that it looks for 'concrete implementation mistakes,' hinting at findings-style output, but says nothing about what is reported, severity, or how failures are surfaced.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though for a validator taking 10 parameters the terseness starts to shade into under-specification rather than pure conciseness.

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

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

There is no output schema, so the description carries the burden of explaining return behavior, and it doesn't — it never says what a finding looks like or what 'concrete implementation mistakes' encompasses. For a 10-parameter validation tool with non-obvious constructs like source-media claims, one sentence is not enough.

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?

With 0% schema description coverage, all 8 required parameters are undocumented in the schema. The description partially compensates by naming four parameter clusters (typography, source-media claims, export assets, timing) that map loosely onto headlinePx/bodyPx/controlPx, media/requiresSourceZip/claimsGeneratedSubjectVideo, files, and duration/fps — but it gives no units, formats, or valid-value guidance.

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

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

The verb 'Check' plus the enumeration of what is checked (typography, source-media claims, export assets, timing) gives a specific, recognizable purpose as a spec-validation tool. It stands reasonably apart from siblings like validate_asset_manifest and check_motion_accessibility, though it never names or contrasts them, so a 4 rather than a 5.

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

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

There is no statement of when to run this versus alternatives such as validate_asset_manifest or plan_launch_preflight, no prerequisites, and no indication of where it belongs in the pipeline. The only signal is the implicit 'validate before shipping' framing, which the agent must infer.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint:false and openWorldHint:true, so the safety profile is covered by structured data. The description adds only that the endpoint is 'public' (consistent with openWorldHint) and lists return payloads; with annotations carrying the safety burden, the marginal behavioral value is thin, and nothing about auth needs, network failure modes, or what happens on an unreachable endpoint is disclosed.

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

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

A single, front-loaded sentence with no filler. The output clause ('digest, resource findings and catalog media consistency') is dense jargon but compact, and every clause carries 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?

With no output schema, the description does usefully enumerate return payloads (digest, resource findings, catalog media consistency), which partially substitutes. But for an openWorld network-fetch tool it omits failure behavior and auth/config prerequisites, and it never explains the id parameter, leaving real gaps.

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

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

Schema description coverage is 0% and the sole parameter 'id' is undocumented in both schema and description. The description never states what the id identifies (template? source record?) or its format, so it fails to compensate for the coverage gap on a required parameter.

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

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

The description states a concrete verb and resource (fetch the configured public source endpoint) and names the outputs. However, it never explains the 'verify' framing implied by the tool name, nor does it distinguish this from the sibling get_template_source, which presumably also fetches source. An agent cannot tell from this text alone when to use one over the other.

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 the sibling get_template_source as an alternative. The only hint at usage is the word 'configured', which implies it only works when a source is already set up, but this 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.