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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only describes the action without mentioning side effects, failure modes, prerequisites, or success indicators. This leaves significant transparency gaps.

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

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

The description is a single 14-word sentence that directly states the core function. It is front-loaded, concise, and every word contributes meaning.

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

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

With no output schema and no annotations, the description is incomplete. It does not explain what happens after adding the effect (return value, errors), how effectSettings are applied, or any constraints (e.g., valid layer types). For a tool with 4 parameters and flexible behavior, more context is needed.

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

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

The schema provides 100% coverage for all parameters with descriptions. The tool description adds the clarification that display names are accepted (not just matchName), which is not explicit in the schema. However, this is a minor addition beyond the already-complete 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 clearly states the verb 'Add', the resource 'After Effects effect to a layer', and the specific method 'by matchName or display name'. This distinguishes it from sibling tools like apply-effect or apply-effect-template by emphasizing its general applicability and the naming convention.

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 'any After Effects effect' implies a general-purpose use case, and the parameter hint about preferring matchName gives some context. However, there is no explicit guidance on when to choose this tool over alternatives like apply-effect, nor any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It mentions marker attributes but fails to disclose behaviors like the default time (current time), default marker type ('layer'), or potential side effects (e.g., modifying the composition). For a mutation tool, this is insufficient.

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

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

The description is two concise sentences, front-loaded with the action and target, and contains no unnecessary words. Every sentence contributes meaning.

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

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

This tool has 10 parameters, no output schema, and no annotations, yet the description provides minimal context. It does not explain required parameters (compIndex), the distinction between layer and composition markers, or how it differs from the sibling add-markers-bulk. The complexity demands more than this.

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 100%, so the schema already documents all 10 parameters. The description adds marginal value by listing the marker attributes (comment, label color, chapter, URL, duration) but does not explain parameter relationships or defaults beyond the schema.

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

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

The description clearly states 'Add a marker to a layer or composition at a specified time' with a specific verb and resource, and lists what markers can include. However, it does not explicitly distinguish from the sibling tool add-markers-bulk, which is very similar.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no exclusions. The description simply states what it does without providing usage context.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only states the operation (add) but does not disclose side effects, prerequisites (e.g., valid comp or layer), edge cases, or whether it appends to existing markers. For a write operation, more transparency is expected.

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

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

Two sentences, front-loaded with purpose, and the second sentence gives actionable use context. Zero wasted 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?

Given moderate tool complexity and full schema coverage, the description covers purpose and primary workflow (audio waveform peaks). With no annotations or output schema, it could still mention potential errors or limits, but the current description is sufficient for basic correct use.

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 100%, so the parameters are already well documented. The description adds the high-level intent (bulk adding) but no additional parameter-specific semantics beyond what the schema provides, aligning with the baseline for full schema coverage.

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

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

Clear verb 'Add' with resource 'markers' and explicit bulk scope ('multiple', 'at once'). Distinguishes from sibling 'add-marker' by emphasizing batch operation and supports both layer and composition markers.

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?

Explicitly states when to use: after analyze-audio-waveform to place detected peaks, or for any batch marker addition. Does not name alternative single-marker add-marker, but the context is clear enough.

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

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

No annotations are provided, so the description carries the full burden. It transparently explains the comp-selection precedence and the template prerequisite, which adds useful behavioral context. However, it does not disclose whether the render starts automatically, how existing render-queue items are affected, or what the return value or error behavior is—gaps that matter for a mutation tool.

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

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

The description is three short sentences, front-loaded with the core action, followed by selection rules and a necessary prerequisite. Every sentence earns its place, with no filler or redundant restatement of the tool name.

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

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

For a tool with 7 optional parameters, no required parameters, no output schema, and no annotations, the description covers the core task and key decision logic (comp selection, template existence). It could more explicitly state that this tool only queues/configures and that a separate sibling such as start-render is needed to actually start rendering, but the schema handles parameter details and the overall picture is largely complete.

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

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

The schema already covers 100% of parameters, so a baseline of 3 applies. The description adds meaning beyond the schema by framing compName as most reliable, clarifying compIndex as a fallback, and explaining the active-comp behavior when both are empty. It also reinforces that templates must pre-exist, which directly applies to the two template 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 clearly states the tool's function: 'Add a composition to the After Effects render queue and configure its output.' It uses a specific verb and resource, and the comp-selection details distinguish it from sibling tools like start-render or render-queue, which focus on different stages of the rendering workflow.

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

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

The description provides concrete selection guidance: compName is 'most reliable', compIndex is 1-based and used only if compName is omitted, and leaving both empty uses the active comp. It also notes the prerequisite that templates must already exist. It does not explicitly contrast with sibling tools like start-render or render-status, but the intended usage is reasonably clear.

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

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

With no annotations, the description carries the full burden. It discloses the return format (normalized amplitude values and peak times), the transcoding behavior for non-WAV formats, dependency on ffmpeg, and the env var override. This adds substantial behavioral context beyond the input schema, though it doesn't mention error conditions or performance characteristics.

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

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

The description is dense but well-organized: purpose, prerequisite step, return details, and format handling. Each sentence earns its place, no fluff. The structure front-loads the core purpose and then provides critical workflow and dependency information.

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

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

Given two params, no output schema, and no annotations, the description covers the essential workflow (get-audio-info first), output shape, and format constraints. It doesn't explain what 'peaks/transients' mean or specify time intervals, but these are not critical for selecting or invoking the tool correctly. Overall, it's fairly complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by clarifying filePath semantics ('WAV works with no extra dependency; other formats need ffmpeg') and numPoints ('Higher = more detail'). These reinforce and extend the schema descriptions, making the tool easier to invoke correctly.

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

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

The description explicitly states 'Analyze an audio file to extract waveform amplitude data and detect peaks/transients.' This is a specific verb+resource+scoped purpose, and it distinguishes from siblings like get-audio-info (which likely returns metadata) and animate-to-audio (which uses audio for animation).

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 clear usage context: 'First call get-audio-info to retrieve the sourceFilePath, then pass it here.' It also explains when ffmpeg is needed versus native WAV support. However, it doesn't explicitly contrast with alternatives like animate-to-audio or state when not to use this tool, so it falls short of a fully explicit when-not/alternatives statement.

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

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

With no annotations, the description carries the full burden. It explains key behavioral aspects like normalization with auto-detected input range, mapping to output range, response curve, and smoothing. However, it omits the default destructive behavior of clearing existing keyframes (clearExisting defaults to true in the schema), which is a significant side effect not disclosed in the description.

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

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

The description is well-structured and front-loaded, starting with the core purpose and then progressively adding necessary detail. It is concise for the complexity, covering input modes, normalization, and targeting in a few sentences without unnecessary fluff, earning its length.

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

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

Given the tool has 22 parameters with comprehensive schema descriptions, the description provides a solid high-level overview that ties concepts together. It covers the main usage patterns and normalization logic, but could mention default behaviors like clearExisting and the max 2000 points limit (though that is in the schema). Overall, it is adequate for a complex tool with rich schema support.

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 100%, so baseline is 3. The description adds significant meaning by explaining the normalization logic that ties inputMin/inputMax to outputMin/outputMax, and clarifies the relationship between data vs values+interval modes. It also introduces the concept of targeting effect properties, enriching the schema's existing parameter descriptions.

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

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

The description clearly states it 'Generate After Effects keyframes for a layer property directly from an arbitrary numeric data series', specifying the action, resource, and input type. It also distinguishes itself from the sibling tool animate-to-audio by explicitly stating 'not audio; see animate-to-audio for that', providing clear differentiation.

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

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

It provides explicit usage guidance by contrasting with animate-to-audio and explaining the two mutually exclusive input modes (data vs values+interval). It also clarifies when to target effect properties versus plain layer properties, offering clear when-to-use and when-not-to-use instructions.

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

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

With no annotations, the description carries the transparency burden and handles it well. It discloses mode-specific behaviors (continuous waveform following vs. pulse-and-decay peaks), keyframe generation details (one per sample), and property targeting (plain layer vs. effect property). It also notes format dependencies, though it stops short of mentioning undo or error handling.

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

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

It is a dense but well-structured paragraph: purpose, then modes, then compatibility and targeting. Every sentence contributes useful information without fluff, and the length is appropriate for the tool's complexity.

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 22 parameters and no output schema, the description covers all critical aspects: main purpose, mode semantics, supported audio formats, and property targeting. It could mention preconditions like composition existence, but overall it is highly complete for the given complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value beyond the schema by explaining how numPoints maps directly to keyframe count and is intentionally capped lower than analyze-audio-waveform. It also clarifies how curve affects peaks mode, enhancing parameter understanding.

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

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

The description opens with a specific verb and resource: 'Generate After Effects keyframes for a layer property directly from an audio file's waveform, in one call.' It clearly distinguishes itself from the sibling analyze-audio-waveform by saying 'no need to call analyze-audio-waveform and compute keyframes by hand first,' and elaborates on two modes to clarify its 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?

It provides explicit usage context, explaining when to use it (for audio-driven keyframes) and describing two modes with example effects. It references the sibling analyze-audio-waveform for format compatibility. While it doesn't explicitly enumerate alternatives like setLayerKeyframe, it clearly implies this is the preferred automated approach versus manual keyframing.

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?

Since there are no annotations, the description carries the full burden of revealing behavioral traits, but it only restates the action 'Apply an effect.' It does not mention side effects, reversibility, requirements, or return behavior, providing essentially no beyond-name transparency.

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

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

The description is a single short sentence with no unnecessary words, making it concise and front-loaded. However, it is somewhat sparse and could have used the spare space to add useful context, so it does not reach a perfect 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 9 parameters, no output schema, no annotations, and many overlapping sibling tools, the description is severely underspecified. It does not address return values, expected behavior, parameter selection strategies, or relationship to other tools, making it inadequate for a tool of this complexity.

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

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

The input schema already provides descriptions for all 9 parameters, giving 100% coverage, so the baseline is 3. The description itself adds no parameter guidance and does not help disambiguate the overlapping effect identifiers (e.g., effect vs effectName vs effectMatchName), but it is not required to due to schema coverage.

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

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

The description clearly states the action ('Apply'), the object ('an effect'), and the target scope ('to a layer in After Effects'). However, it does not distinguish this tool from sibling tools like add-any-effect or apply-effect-template, so it lacks sibling differentiation.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any prerequisites, exclusions, or conditions. It is a bare statement of action without contextual usage advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without explaining important traits like whether existing effects are replaced, whether the operation is reversible, or what 'applying a template' actually entails (e.g., adding multiple effects, modifying layer properties).

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

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

The description is a single, direct sentence with no filler words. It efficiently communicates the core action and target resource, earning its place without redundancy.

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

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

Given the tool's moderate complexity (4 parameters, optional nested object, no output schema), the description is too sparse. It fails to explain what a 'predefined effect template' is, how customSettings override defaults, or any side effects, leaving the agent without enough context to predict the tool's full behavior.

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 100%, with clear descriptions for compIndex, layerIndex, templateName (including an enum of available templates), and customSettings. The description adds no parameter-specific information, so the baseline of 3 applies.

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

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

The description clearly specifies the action ('Apply') and the resource ('a predefined effect template to a layer in After Effects'). It distinguishes from sibling tools like 'apply-effect' by emphasizing 'predefined template', which implies a package of effects rather than a single effect.

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

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

The description provides no guidance on when to use this tool versus alternatives such as 'apply-effect' or 'apply-preset'. It does not mention any prerequisites, selection requirements, or scenarios where a template would be preferred over a simple effect or preset.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action but does not explain whether the preset replaces existing effects, what compatibility requirements exist, or what the result/consequences are on the layer. This is a significant gap for a mutation tool.

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

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

The description is a single, focused sentence that conveys the core action without unnecessary words. It is front-loaded with the verb and resource, making it instantly understandable.

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

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

The tool is a simple mutation, but the description lacks critical behavioral context (e.g., side effects, prerequisites) and there is no output schema to describe return values. With no annotations, the description should be more comprehensive to be complete for an agent.

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

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

The input schema has 100% description coverage for all three parameters (compIndex, layerIndex, presetPath). The description adds no extra meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the specific action: applying an After Effects .ffx preset file to a layer. It distinguishes itself from sibling tools like apply-effect (which likely applies effects by name) by specifying the preset file format.

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

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

No guidance is given on when to use this tool versus alternatives like apply-effect, apply-effect-template, or other preset-related tools. The description implies usage (applying a preset) but does not provide context, 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?

With no annotations provided, the description carries the full burden. It discloses a key side effect—'Setting position clears its existing keyframes first'—and enumerates the properties affected, which is useful transparency for a mutation tool. It does not mention other potential side effects like whether other property sets clear keyframes, but this is a minor gap.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence adds value. It summarizes what the tool does, how operations are targeted, and an important side effect without redundancy.

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 batch property-setting tool with no output schema, the description covers the main functionality, property options, and a notable side effect. It does not mention return values or error behavior, but these are less critical and the schema fills in comp selection and property formats.

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

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

The input schema provides 100% coverage with descriptions for all parameters, including the operations array structure and property details. The description adds context about keyframe clearing and the batch nature, but the schema already explains the parameter meanings well, so baseline 3 is appropriate.

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

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

The description begins with a specific verb-resource pair ('Set transform/visibility properties on MANY layers') and clearly distinguishes this batch operation from singular tools like setLayerKeyframe. The scope ('MANY layers') and property list are explicit.

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

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

The description clearly implies a batch use case ('on MANY layers in one call') and lists the properties that can be set, which differentiates from single-layer alternatives. However, it does not explicitly state when not to use it or name alternative tools for single-layer operations.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It only states the action without mentioning side effects, such as modifying layer position values, whether the operation is reversible, or how nesting/anchors are handled. For a mutation tool, this is a notable gap.

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

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

A single, front-loaded sentence with zero redundancy. Every word contributes to conveying the tool's purpose, achieving high efficiency.

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

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

The tool has 5 parameters, but the description omits how they interact (e.g., whether allLayers overrides other selectors, or if selectedOnly is ignored when layerName is set). Given no output schema or annotations, this missing behavioral context is a significant gap 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 100%, so parameters are already well-documented. The description adds no extra semantics beyond echoing selectors like 'selected layers' and 'all layers'. It does not clarify precedence or combinations, but baseline 3 is appropriate since schema handles explanations.

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

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

The description clearly states a specific verb ('Center') and resource ('one layer, selected layers, or all layers in a composition'), distinguishing it from all sibling tools. It immediately communicates the tool's core functionality without ambiguity.

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

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

The description implies clear usage contexts: centering individual layers, selected layers, or all layers. While it doesn't explicitly mention alternatives or when-not-to-use, there are no close sibling tools for centering, so the scope is evident and consumers can infer appropriate scenarios.

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

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

With no annotations, the description carries the full burden of disclosure. It communicates that the tool is a read-only verification and lists what it reports, implying non-destructive behavior. It also discloses the health-check nature and a possible remediation step. It could be stronger with an explicit non-mutating statement, but it is already clearly safe and informative.

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

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

The description is three sentences long and front-loads the purpose with 'Health check'. Every sentence earns its place: purpose and output, usage timing, and troubleshooting tip. There is no filler or redundancy.

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

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

The tool is simple (no params, no output schema), but the description compensates by listing the expected returned fields (version, AE version, bridge folder, project/active comp). It also tells the agent when to run it and what to do on mismatch, making the tool fully usable without additional documentation.

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

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

The tool has zero parameters, and the schema has no properties. The description wisely avoids inventing parameter details and focuses on behavior and output, which aligns with the baseline for parameterless tools. Nothing more is needed.

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?

Description begins with 'Health check' and uses specific verb 'verify', clearly stating it checks that the After Effects MCP Bridge panel is open and responding. It enumerates the report contents (version, AE version, bridge folder, open project/active comp), which unambiguously identifies the tool's function and differentiates it from sibling tools like run-bridge-test.

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?

Explicitly instructs 'Run this FIRST when anything times out or behaves oddly', giving a clear condition for use. It also provides an alternative action for a version mismatch: re-run `npm run install-bridge` and restart After Effects, which tells the agent what to do next rather than just describing the tool.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly explains the process: sample frames across the duration, composite them into a labeled grid, and return a single image. It also addresses comp selection (name, 1-based index, or active comp). It does not mention timeout or resource implications, but the behavior is well-articulated.

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

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

The description is two sentences, front-loaded with the core value proposition ('See a composition's whole timeline at a glance'), followed by the method and selection instructions. Every sentence earns its place with no redundancy.

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 or annotations exist, so the description must cover the return value and key behaviors. It does so by stating the output is a single labeled image and explaining comp selection. The remaining parameters are well-documented in the schema, and the use case is clear. Minor gaps like timeout behavior are not critical for 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 coverage is 100%, so the baseline is 3. The description adds minimal meaning beyond the schema: it reiterates the comp selection options and clarifies '1-based index', but does not elaborate on count, maxWidth, or timeoutMs. This is sufficient since the schema already documents each 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 clearly states the tool's function: rendering N frames from a composition and compositing them into a single labeled thumbnail grid. It uses a specific verb (render/composite) and resource (composition timeline), distinguishing it from sibling tools like see-frame or get-layer-clip-frames.

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

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

The description provides clear usage context ('Use this to perceive motion, timing, and easing cheaply') and explains the advantage of one image over many. It does not explicitly name alternatives or state when not to use it, but the guidance is sufficient for an AI to choose appropriately.

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

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

No annotations are provided, and the description carries the full burden. It only states that it creates an adjustment layer but does not disclose any behavioral traits such as side effects, error handling, or what happens if the comp isn't found. For a mutation tool, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the verb and resource clearly, making it both concise and structured.

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

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

Given the tool's simplicity, the description plus schema provide a reasonable understanding. However, it lacks information about return values or error behavior, and with no annotations, it's only minimally complete for a mutation 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?

Input schema coverage is 100% with all six parameters described in the schema. The tool description itself adds no parameter details, but the schema already provides sufficient meaning, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Create an adjustment layer') and the target ('in the specified composition (or active comp)'). It is specific and distinct from sibling tools like create-composition or apply-effect.

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

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

The description implies when to use the tool (when creating an adjustment layer in a comp), but it does not explicitly mention alternatives, exclusions, or prerequisites. There's no guidance like 'use this instead of create-composition'.

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

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

With no annotations provided, the description bears the full burden. It discloses the comp selection behavior (compName/compIndex or active comp) but omits details about side effects, failure modes, or creation defaults such as default position. The mutation nature is implied by 'create' but not elaborated.

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

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

The description is two concise sentences: the first states the purpose, the second explains comp selection. Every sentence earns its place without unnecessary detail.

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

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

The schema richly describes all 7 parameters, and the description adds comp selection logic. However, there is no output schema and no mention of return values or failure behavior, leaving some context incomplete for a creation 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 100%, so the baseline is 3. The description adds a note about comp selection, overlapping with the schema's own descriptions, but does not add new semantics for parameters like position, zoom, or oneNode.

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

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

The description clearly states 'Create a camera layer in a composition' with a specific verb and resource, and adds comp selection details that distinguish it from sibling create tools like create-composition or create-adjustment-layer.

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

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

The description implies usage for creating camera layers and explains how to target a comp (by name, index, or active), but it does not explicitly discuss when to use this tool versus alternatives or provide exclusions. No alternative tools are mentioned.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool creates a new composition but doesn't mention default behavior (e.g., default duration/frameRate if omitted) or whether it overrides an existing comp. The schema provides defaults for some parameters, but the description adds no extra behavioral context. Since creation tools are generally non-destructive (new resource), the lack of warning is acceptable, but the description could mention that existing comps are not affected.

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

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

The description is a single sentence with no filler words. It is front-loaded with the action ('Create') and resource ('a new composition'), making it immediately clear. Every word serves a purpose, and it is neither verbose nor under-specified.

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

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

For a creation tool with a rich schema (7 parameters, all documented), the description doesn't need to explain return values (no output schema). It could mention that the composition is added to the project panel or the current project, but this is implied by 'in After Effects.' The lack of annotations and output schema lowers the burden, but the description could be a bit more explicit about the context (e.g., the composition is created in the active project). Overall, it is minimally complete but not exceptional.

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 100%, so the schema already documents all 7 parameters thoroughly. The description's phrase 'specified parameters' is generic. Consequently, the description adds no extra meaning beyond the schema. A baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description states the verb ('Create') and resource ('a new composition in After Effects'), which clearly identifies the tool's function. It doesn't distinguish from sibling tools explicitly, but siblings like 'create-adjustment-layer' are different enough that no confusion is likely. A more specific mention of parameters like width/height/duration would strengthen it, but the current wording is adequate.

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 the context ('Create a new composition in After Effects') but no explicit when-to-use or alternatives. It implies that this is the go-to tool for creating comps, especially since siblings don't include another composition creator. However, no prerequisites or exclusions are mentioned, making it minimally adequate.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does explain the auto-detection of direction and default alignment for RTL, which is valuable. However, it doesn't mention behavior around composition selection, error handling, or side effects (e.g., whether it replaces existing layers). This is adequate but not comprehensive.

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

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

The description is three sentences long, front-loaded with the core action, and every sentence adds value. It efficiently covers the unique feature (Arabic/RTL) and the practical 'works in any language' note without fluff.

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

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

Given the tool's complexity (10 parameters, no output schema), the description covers the essential context: what the tool does, its primary differentiator, and compatibility. It doesn't explain return values or errors, but for a creation tool that's typically implicit. It's nearly complete for the target use case.

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 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining how `direction` interacts with `alignment` (auto-detection, forcing, default right-alignment for RTL) and by suggesting font families that support Arabic. This clarifies the most nuanced parameter relationships.

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

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

The description uses a specific verb+resource ('Create a text layer') and clearly distinguishes this tool from siblings like create-adjustment-layer or create-composition by highlighting full Arabic/RTL support. It immediately communicates the tool's unique value proposition.

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

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

The description provides clear context for when to use this tool: whenever a text layer is needed, especially for Arabic/RTL content. It doesn't explicitly name alternatives or exclusions, but the phrasing 'Works on After Effects in any language' implies broad applicability. Slight lack of explicit alternative guidance prevents a 5.

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?

This is a destructive operation with no annotations to signal the risk. The description merely says 'Delete' and mentions targeting, but it does not disclose that deletion is irreversible, what happens if both layerName and layerIndex are provided, or what errors occur if no target is specified. The description carries the full burden of behavioral disclosure and fails to address these important safety and edge-case behaviors.

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

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

The description is two sentences, front-loaded with the core action ('Delete a layer from a composition'), followed by the key targeting detail. No filler or redundant content; every word serves the purpose.

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

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

The tool has no output schema and no annotations, and the description does not explain essential operational details. It fails to specify that exactly one of layerIndex or layerName is required (since the schema marks all parameters as optional), or what happens if both or neither are provided. It also does not describe error behavior for missing compositions or layers. Given the simplicity of the tool, these gaps make the description incomplete for reliable agent use.

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 100%, so all parameters are described in the input schema. The description adds 'Target the layer by layerIndex or layerName,' which reiterates the schema's own parameter descriptions but does not add deeper meaning such as mutual exclusivity, precedence, or required-target logic. It provides marginal value beyond the schema, so baseline 3 is appropriate.

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

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

The description states a specific action ('Delete a layer from a composition') with a clear resource (a layer) and context (composition). It distinguishes from sibling tools like duplicate-layer and inspect-layer by naming a unique operation. It also specifies targeting via layerIndex or layerName, making the purpose unambiguous.

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

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

Usage is implied by the verb 'Delete' and the resource type. However, there is no explicit guidance on when to use this tool vs alternatives, no mention of exclusions (e.g., cannot delete locked layers), and no note about requiring a composition to be active. The description provides clear context but no explicit when-to-use or when-not-to-use 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?

With no annotations provided, the description must carry the transparency burden. It states the core operation and optional rename, which implies the original is preserved, but it does not disclose details such as the insertion position of the duplicate, the active comp fallback, or return values.

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

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

The description is a single, front-loaded sentence that states the primary action first and includes only necessary qualifiers. Every word contributes meaning; there is no redundancy or filler.

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 five parameters, no annotations, and no output schema, the description covers the core purpose and targeting but omits cross-parameter constraints and return/error behavior. The schema fills many gaps, but the description could be more complete regarding parameter relationships.

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

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

The input schema provides 100% coverage with descriptions for all five parameters, earning the baseline of 3. The description adds marginal value by restating layerIndex/layerName targeting and optional renaming, but it does not introduce constraints like exclusivity between layerName and layerIndex.

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

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

The description opens with a specific verb 'Duplicate' and defines the resource 'layer in a composition', then adds optional renaming and target selection via layerIndex or layerName. This clearly distinguishes it from sibling tools like delete-layer, inspect-layer, or setLayerKeyframe.

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

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

The description provides clear context that the tool is for creating a copy of a layer and states how to target it. While it does not explicitly name alternatives or exclusions, the purpose is self-evident and no conflicting sibling tool exists, so the implied usage is clear.

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

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

No annotations are provided, so the description carries full burden. It discloses critical behaviors: code runs as a function body, must return JSON-serializable values, the script is wrapped in a single undo group, and errors return message plus line number. It also notes not to call beginUndoGroup.

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

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

The description is dense but every sentence provides necessary guidance. It is front-loaded with the core purpose and immediately follows with usage examples and critical constraints. No redundant filler.

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 that executes arbitrary code, the description is remarkably complete. It covers return contract, serialization, undo behavior, access points, error format, and gives a concrete example. No output schema exists, so the description correctly takes on the burden of explaining what to expect.

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 100%, but the description significantly enhances the script parameter by explaining the function-body execution model, return value requirements, and error behavior. The timeoutMs parameter is only described in the schema, but the description adds no further detail, which is acceptable given full schema coverage.

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

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

The description clearly states the tool runs arbitrary ExtendScript in After Effects and returns the result. It also differentiates from sibling tools by positioning itself as the catch-all for cases not covered by dedicated tools.

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 provides explicit guidance to use the tool for anything the dedicated tools do not cover, with a long list of examples. It clearly implies the alternative (dedicated tools) but does not name specific sibling tools or provide an explicit 'when not to use' statement.

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

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

No annotations are provided, so the description carries the burden. It lists the exact data returned (metadata, source path, markers, keyframes), which provides some transparency. However, it does not explicitly state that the operation is read-only or describe behavior on missing layers, though 'Get' implies no side effects. This is adequate but not highly detailed.

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

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

The description is a single, information-dense sentence that front-loads the verb and resource. It lists the four types of data retrieved without unnecessary elaboration, earning full marks for 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?

For a simple get tool with no output schema, the description lists all the expected return values. It does not detail output format or error conditions, but these omissions are minor given the tool's straightforward read-only nature. The description provides enough context for typical usage.

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

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

The input schema has 100% coverage with descriptions for all parameters, so the schema already explains each parameter. The description adds no extra parameter-level detail, such as how layerName and layerIndex interact. With full schema coverage, the baseline score of 3 applies.

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

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

The description clearly states the tool's function: 'Get audio metadata, source file path, existing markers, and audio level keyframes for a layer in After Effects.' It uses a specific verb ('Get') and resource ('audio info'), and it differs from siblings like 'set-audio-levels' and 'analyze-audio-waveform' by focusing on reading existing data.

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

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

The context is clear: use this tool when you need to retrieve audio-related information for a layer. It does not explicitly mention alternatives or when not to use it, but the descriptive text and tool name imply a read-only retrieval role. Since it does not mention exclusions, it earns a 4.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Get help' without conveying what output to expect, whether it returns a list of commands, or if it has any side effects. The read-only nature is implied but not stated, and no additional behavioral context is given.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose, making it highly concise and well-structured.

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

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

For a simple help tool with no parameters and no output schema, the description provides the essential purpose but lacks details about what kind of help is returned (e.g., command list, usage examples, or links). Since there is no output schema, the description should explain the return value, but it does not, leaving a moderate 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?

The tool has zero parameters and schema description coverage is 100%, so the baseline score is 4. The description does not need to add parameter information because there are none to document.

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

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

The description states a clear verb and resource: 'Get help on using the After Effects MCP integration'. It is more specific than a tautology and identifies the tool as general help, but it does not explicitly distinguish itself from the sibling tool 'mcp_aftereffects_get_effects_help', which appears to be a more specialized help option.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention situations where users should prefer the dedicated effects help tool or any other tool, and it offers no exclusions or contextual examples.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It implies a read-only operation via 'Get', but does not explain error behavior (e.g., layer not found), return format, or whether the tool relies on a selected layer when layerName/layerIndex are omitted.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It conveys the tool's purpose and output data efficiently.

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

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

The tool has no output schema and no annotations, and the description does not clarify critical context like layer selection resolution (layerName vs layerIndex), whether compIndex is sufficient alone, or what happens if the layer is missing. This leaves important gaps for an agent trying to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already explains all three parameters. The description adds no extra parameter-level detail, staying at the baseline 3 for schema-complete cases.

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

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

The description uses a specific verb ('Get') and clearly names the resource ('a layer's clip start/end frames, source frame range, and duration in frames'). It unambiguously states what the tool returns and is distinct from sibling tools, none of which focus on retrieving layer timing data.

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

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

The usage is implied by the purpose (use when you need clip frame information), but there is no explicit guidance on when to use layerName vs layerIndex, or whether one is required beyond compIndex. No alternatives are mentioned, though no sibling tool directly competes.

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

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

With no annotations, the description carries the full burden and clearly signals a read-only retrieval ('Get results'), but it does not disclose what the result payload looks like, whether it can fail, or whether it has side effects. The behavioral description is minimal but not misleading.

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 sentence that front-loads the action and resource with no filler. Every word earns its place.

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

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

Given zero parameters and low complexity, the description is mostly adequate, but the absence of an output schema leaves 'results' undefined. The agent must guess whether it returns a string, object, or status, which is a notable gap for a tool with no other documentation.

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

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

The tool has zero parameters and the schema is 100% covered (empty properties), so the baseline for no parameters applies. The description does not need to explain parameters since there are none.

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

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

The description uses a specific verb+resource ('Get results') and scopes it to the last script executed in After Effects, clearly distinguishing it from sibling execution tools like run-script and execute-script. The subject and scope are immediately understandable.

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

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

The phrase 'last script executed' implies the tool should be used after running a script, providing clear context, but it does not explicitly state when to use it versus alternatives or what happens if no script has been executed. No exclusions or alternative tool references 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?

With no annotations, the description carries the full transparency burden. It discloses the exact output content—settings (size, fps, duration, work area) and layer summary fields—and the comp selection fallback. It does not explicitly state that the tool is side-effect-free, but the 'inspect' and 'Map' framing strongly implies a read-only operation; a direct statement would make it a 5.

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

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

The description is three sentences, each serving a distinct purpose: output specification, usage guidance, and parameter selection. The first sentence is dense but every item in the enumeration is informative; there is no filler or redundancy.

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 compensates by listing every output category in detail (composition settings and a comprehensive layer summary field list). It also explains comp selection and the recommended next action, making the tool fully self-contained for an agent.

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

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

The input schema already covers 100% of parameter semantics, including compName being recommended, compIndex being 1-based, and active comp fallback. The description essentially restates this selection logic without adding new parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb-resource pair ('Map a whole composition') and enumerates exactly what is returned: settings plus every layer with a detailed summary. It clearly differentiates from the sibling tool inspect-layer by noting that one should 'call inspect-layer for one layer's full detail.'

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 explicitly states the intended use case: 'Use this to navigate a comp and decide what to edit, then call inspect-layer for one layer's full detail.' It also provides clear selection guidance for compName/compIndex and the active comp fallback, so the agent knows when and how to use it.

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

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

The description strongly implies read-only behavior via 'inspect' and 'SEE its exact state', and provides detailed output expectations. However, it does not explicitly state that no modifications occur, which with no annotations leaves some ambiguity.

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

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

The description is dense but well-organized, front-loading the purpose and using a list structure to enumerate covered properties without repeating schema fields.

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

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

Given the tool's complexity and absence of an output schema, the description provides a thorough account of return contents (transform, effects, masks, markers, source, text) and selection logic, making it self-sufficient for an agent.

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

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

The schema already fully documents all six parameters (100% coverage). The description adds a brief note on selection options (compName/compIndex, layerIndex/layerName, active comp) but does not add semantics beyond the schema.

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

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

The description clearly states the tool deeply inspects one layer and enumerates the exact state elements (type, transform, effects, masks, markers, source, text). This distinguishes it from sibling tools like inspect-comp or list-layer-effects.

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 frames the tool as a pre-edit inspection step ('before making precise edits') and specifies that it targets a single layer, selected by comp and layer identifiers. It lacks explicit alternatives/exclusions, so not a 5.

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

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

No annotations exist, so the description carries the full burden. It mentions the optional text filter but does not disclose default behavior like exclusion of obsolete effects or result limits, which are only in the schema. For a read-only listing, this is minimal but not misleading.

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 sentence of 13 words that is front-loaded with the action and scope. No unnecessary words or repetition, making it highly concise and well-structured.

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

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

The tool is low-complexity, but with no output schema or annotations, the description needs to carry more context. It omits details about the return format and default filtering behavior, though the schema covers parameter specifics. Adequate but not complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description only mentions the optional filter, which maps to the query parameter, but adds no extra meaning beyond the schema's own parameter descriptions.

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

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

The description clearly states the action (List) and the resource (effects available in this After Effects installation). It distinguishes from sibling tools like list-layer-effects by specifying installation-level scope, making the purpose unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives such as list-layer-effects or search-presets. The description does not mention any exclusions or trade-offs, leaving the agent to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read operation ('List') but does not explicitly state safety, edge-case behavior, or how recursion affects output. The optional recursion hint is present but underelaborated.

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

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

The description is a single, concise sentence with no redundant words. It front-loads the primary action and mentions the optional capability efficiently.

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

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

Given there is no output schema, the description should explain what the returned list looks like or what 'effects' includes. It also lacks context about parameter relationships (e.g., maxDepth only matters when includeProperties is true) and does not mention any limitations or prerequisites.

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 100%, so the baseline is 3. The description adds the phrase 'recursive property details' which loosely maps to includeProperties/maxDepth, but it does not meaningfully enhance understanding beyond the already-detailed 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 clearly states the tool's action ('List effects on a layer') and indicates an optional feature ('recursive property details'). While it doesn't explicitly differentiate from sibling tools like list-available-effects, the focus on 'on a layer' makes the purpose clear enough.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of when to prefer list-layer-effects over list-available-effects or other inspection tools, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description must carry the full behavioral disclosure burden. It implies a read-only operation ('List available') and specifies the source folders, but it does not state what the tool returns (e.g., file paths vs. names), whether it requires After Effects to be running, or any limits like recursion defaults. This is adequate for a simple list tool but lacks depth.

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

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

The description is a single sentence, containing only 10 words, and is front-loaded with the core action ('List available After Effects .ffx presets'). Every word is purposeful and there is no redundant 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?

The tool is simple, but there is no output schema, so the description should clarify what the tool returns. It does not. Additionally, with sibling search-presets present, the description could have mentioned how list-presets differs (e.g., 'lists all presets from folders, while search-presets filters by query'). Overall, it provides the basic purpose but leaves these contextual 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?

The schema provides 100% description coverage for all four parameters, so the baseline is 3. The tool description adds minimal semantic value beyond the schema; 'common or provided folders' merely paraphrases the schema's presetRoots description, and no details about maxDepth, recursive, or maxResults are included in 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 uses a specific verb ('List'), identifies the resource ('After Effects .ffx presets'), and specifies the scope ('from common or provided folders'). This clearly distinguishes it from sibling tools like apply-preset and search-presets by focusing on enumeration from filesystem locations.

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

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

The description provides clear context for when to use the tool (when you need to discover available presets from common or custom folders), but it does not explicitly mention alternatives or when not to use it. Since sibling search-presets exists, a brief note on how it differs would have made this a 5.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains that the whole composition is duplicated first, preserving all layers/effects/animations, details how nested precomps are handled without modifying originals, and mentions auto-detection of Arabic with RTL. It falls short of explicitly stating whether the source composition itself is modified, but overall it is highly transparent.

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

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

The description is a single dense paragraph that front-loads the primary purpose and uses every sentence to add value (duplication behavior, nested precomp handling, RTL logic, caller responsibility). It is appropriately sized for the tool's complexity, though slightly long.

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 covers the tool's core functionality well: duplication, text swapping, path handling, and RTL detection. It does not explicitly mention return values or what happens after creation, but given the complexity and rich schema, the description is largely complete. Slight gaps exist around source comp modification and any side effects.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema, especially for the complex `path` parameter (explaining precomposition duplication/reuse) and clarifying that `translations` should contain already-translated strings. This extra guidance enhances understanding of the 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 clearly states the tool creates a localized duplicate of a composition by swapping in translated text for text layers. It uses a specific verb ('Create') and specifies the resource ('localized duplicate of a composition'), and the mention of 'same logic as create-text-layer' helps distinguish it from that sibling 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?

The description implies when to use the tool (localizing a composition) and notes that translation is the caller's job, but it does not explicitly state when not to use it or compare it to alternatives like create-text-layer or duplicate-layer. Usage context is clear but without explicit exclusions.

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

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

With no annotations, the description carries the full burden, and it provides useful behavioral details: it renders the current frame, returns a side-by-side and a difference map, and explains that the difference map is bright where they differ. It does not disclose whether the operation is non-destructive or what happens with invalid reference paths, but it does not contradict annotations and offers more than a minimal description.

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

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

The description is efficient, with two sentences that are front-loaded with the primary verb and resource. It packs meaningful details (rendering, output types, difference map interpretation, and comp selection) into a compact space without redundant or verbose wording.

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

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

Given that there is no output schema, the description sufficiently explains what the tool returns and how to specify inputs, allowing an agent to invoke it confidently. It could additionally mention the time parameter or error handling, but those are at least partially covered by the input schema, so the overall completeness is high.

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

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

The schema covers 100% of parameters with descriptive text, so the baseline is 3. The description does not add new meaning beyond what the schema provides—it only restates the comp selection rule and the need for an on-disk path, both already in the schema. No additional parameter semantics are introduced.

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

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

The description opens with a specific verb+resource phrase, 'Compare a composition against a reference image,' and clearly distinguishes the tool from siblings like see-frame or contact-sheet. It further details the two outputs (side-by-side and difference map) and explains the purpose of seeing exactly where the render deviates.

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 clearly implies when to use this tool: when you need to compare a composition against a reference and converge on a match. It does not explicitly name alternatives or exclusions, but within the context of sibling tools this is the only comparison-focused tool, making the usage clear.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It merely states the purpose without mentioning that the operation is read-only, what output to expect, or any other behavioral traits. The implication of 'help' being non-destructive is weak.

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

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

The description is a single, directly stated sentence with no filler words. It conveys the core purpose efficiently and is appropriately sized for a tool with no 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?

The description is adequate for a simple help tool, but it lacks details about the output format or what kind of help is returned. Since there is no output schema and no annotations, the description should explain what the agent will receive, but it does not.

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

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

The tool has zero parameters and an empty schema, so the baseline for parameter semantics is 4. The description adds no parameter information, but none is needed since there are no parameters to document.

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

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

The description clearly states the tool's purpose: providing help on using After Effects effects. The verb 'Get help' and the resource 'After Effects effects' distinguish it from general help tools like 'get-help' and effect listing tools like 'list-available-effects', though it doesn't elaborate on what the help includes.

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 offers no guidance on when to use this tool versus similar siblings such as 'get-help' or 'list-available-effects'. It does not mention any alternatives, 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?

The description discloses the core behavior but omits any side effects, irreversibility, or error conditions. With no annotations available, the description carries the full burden and does not clarify what happens when removing an effect fails or when removeAll is combined with effectName.

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

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

The description is a single, brief sentence that immediately states the purpose. It follows a clear structure with no filler.

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 six parameters and no output schema or annotations, the description is too thin. It does not explain how the effect selection parameters (effectIndex, effectName, effectMatchName) interact, nor what happens if none are specified when removeAll is false. This leaves the agent uncertain about invocation requirements.

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

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

The input schema already describes all six parameters with 100% coverage, so the baseline is 3. The description adds only the high-level distinction between removing one effect versus all, which is also captured by the removeAll parameter 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 clearly states the action ('Remove') and the target ('effect' on a 'layer'), and mentions the dual mode (specific or all). This distinguishes it from sibling tools like apply-effect or list-layer-effects.

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

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

No guidance is provided on when to use this tool versus alternatives like set-effect-property or list-layer-effects. The description does not mention contexts in which removal is appropriate or if there are prerequisites.

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

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

With no annotations provided, the description carries full transparency burden. It discloses background/headless execution, the save-first default, projectPath override, immediate return, and waitMs behavior. It omits error-handling details but covers core behavioral traits.

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

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

The description is compact, front-loaded with purpose, and each sentence adds value: purpose, differentiation, requirement, default behavior, and return semantics. No redundant 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?

Given the 9-parameter schema and no output schema, the description sufficiently covers main usage, prerequisites, async behavior, and follow-up. It does not spell out the return value format, but 'Check progress with render-status' implies a handle is returned.

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 100%, so baseline is 3. The description adds prose context for projectPath and waitMs, clarifying how they alter execution. It also explains the saveFirst default, enriching the schema's 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 clearly states the tool renders a composition to a file in the background using aerender, and explicitly contrasts it with start-render. This distinguishes it from siblings and gives a specific verb, resource, and execution mode.

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?

Provides explicit when-to-use guidance: 'Unlike start-render, this does NOT freeze your After Effects UI'. Also states the project-save requirement and directs the user to render-status for progress, effectively outlining a 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly mentions destructive actions ('clear the whole queue', 'remove a single item by index'), which is good, and notes that list returns 'status and output path'. However, it does not disclose whether clear is irreversible, whether permissions are needed, or how the 'remove' action behaves with an invalid index. This is adequate but not rich.

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

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

The description is a single, concise sentence that front-loads the purpose ('Inspect or manage') then efficiently enumerates the specific actions and their targets. Every word adds value; no repetition of parameter names or schema details.

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

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

For a multi-action tool with two parameters and no output schema, the description is quite complete: it covers all three actions and hints at return data for list. It lacks details on error handling or edge cases (e.g., invalid index), but given the tool's moderate complexity and the clear param descriptions, this is sufficient. The presence of sibling tools like render-status further reduces the need for extensive explanation.

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 100%, so baseline is 3, but the description adds meaningful context beyond the schema: it ties 'index' to the remove action ('remove a single item by index') and clarifies the list output ('status and output path'). This reinforces and extends the parameter semantics already provided in the input 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 uses a specific verb phrase 'Inspect or manage' with a clear resource 'After Effects render queue' and enumerates specific actions (list, clear, remove). It distinguishes from sibling tools like render-status and start-render by focusing on queue inspection and mutation rather than status or rendering execution.

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 clearly conveys usage context by listing the three actions available ('list', 'clear', 'remove') and their effects, implying when to use this tool versus render-status or start-render. It does not explicitly name alternative tools or state when-not-to-use, but the action-based guidance is clear enough for an agent to select this tool for queue management tasks.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool checks statuses and reads log tails, implying a read-only operation. However, it does not explicitly state that it has no side effects, what happens for invalid PIDs, or any permission requirements, leaving some behavioral uncertainty.

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

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

The description is a single, highly informative sentence. Every clause adds value: the tool scope, the specific checks, and the log output. No redundant or filler content exists.

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 low-complexity status tool with one optional parameter and no output schema, the description adequately covers what the tool reports (running/finished statuses and log tails). It lacks explicit mention of the return format, but the description gives enough conceptual detail for correct selection and invocation.

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

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

Schema description coverage is 100%: the pid parameter is described as 'Optional specific render PID. If omitted, reports all tracked renders.' The tool description adds no additional parameter detail, so it does not elevate beyond the schema baseline.

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

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

The description uses a specific verb ('Check') and identifies the exact resource ('background aerender renders started with render-aerender'). It clearly distinguishes this tool from siblings by scoping it to aerender background renders and specifying outputs (running/finished status, log tails), which sets it apart from render-queue or start-render.

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

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

The description specifies when to use this tool: after renders have been started with render-aerender. It clearly implies the usage context (checking status of those background renders) without explicitly naming alternatives or exclusions, but the scope is unambiguous.

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

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

With no annotations provided, the description carries full burden for transparency. It does disclose that the tool 'applies test effects', indicating side effects, but it does not explain what those effects are, whether they are destructive, reversible, or impact the current project. The behavior beyond 'verify communication' is vague, leaving the agent uncertain about possible outcomes.

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

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

The description is a single, compact sentence that directly conveys the tool's function without any filler or redundancy. It is front-loaded with the action ('Run') and the resource ('bridge test effects script'), earning high marks for efficiency.

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

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

Given the tool has no parameters and no output schema, the description is the sole context. It provides the basic purpose but leaves gaps about the nature of 'test effects' and the expected outcome. While it is minimally viable, an agent might struggle to predict the tool's impact on the environment, so the description could be more detailed.

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

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

The input schema is empty, meaning there are no parameters. The description correctly makes no mention of parameters, and because there are none, there is no semantic gap. Baseline 4 is appropriate for a zero-parameter tool.

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

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

The description clearly states a specific action ('Run the bridge test effects script') and its dual purpose ('verify communication and apply test effects'). This distinguishes it from siblings like 'run-script' (generic script runner) and 'check-bridge' (only checks communication), making the tool's role unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or that it should be used before/after other operations. The purpose implies a testing scenario, but the description fails to explicitly state this context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that the script is read-only, which is valuable safety information, and adds context beyond the schema. It could mention more about side effects or error behavior, but the read-only qualifier provides meaningful transparency.

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

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

The description is a single sentence that directly states the purpose and key qualifier. It is concise, front-loaded, and contains no unnecessary 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?

The tool has a simple interface with clear schema coverage, but no output schema is provided. The description does not explain what the script returns or how results are delivered, leaving a gap for a script runner. It is adequate for basic understanding but could be more complete, especially for a tool that runs arbitrary predefined scripts.

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

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

The schema already provides descriptions for both parameters with 100% coverage, so the description does not need to compensate. The description adds nothing about parameter semantics, and the baseline of 3 is appropriate given the schema's completeness.

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

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

The description clearly states the action (run), the resource (a script), and the context (After Effects) while adding the qualifier 'read-only' to define the script's nature. This distinguishes it from the sibling tools, which focus on effects, layers, and compositions, not script execution.

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

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

The description implies this tool is for executing predefined scripts that are read-only, clearly differentiating it from effect-related tools. However, it does not explicitly state when to use it over alternatives or provide exclusion criteria, but the uniqueness among siblings makes the usage context clear.

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

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

No annotations are provided, so the description carries full burden for disclosing behavior. It only states it 'searches' and does not mention return format, recursion or depth defaults, limitations, or that it reads from common Adobe preset locations. This is minimal beyond the obvious read-only nature of 'search'.

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

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

The description is a single sentence, uses no filler, and is front-loaded with the key action and resource. It earns its place with zero wasted 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?

Despite having 5 parameters and no output schema or annotations, the description does not mention return format or typical use context. It only states the basic purpose, leaving the agent to infer behavior from the schema. The tool is relatively simple but should have disclosed more about 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 100%, so each parameter already has a clear description. The tool description adds no additional parameter meaning, but this is acceptable per the baseline rule for high schema coverage.

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

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

Clearly states what the tool does: searches After Effects .ffx presets by name or path. Provides a specific verb ('Search') and resource ('.ffx presets'), distinguishing from siblings like list-presets or apply-preset.

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

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

The description implies usage when one needs to find a preset by searching for a name or path, but it does not explicitly contrast with sibling tools like list-presets or provide exclusions. No clear 'when-not-to-use' guidance beyond the inherent verb.

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

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

No annotations exist, so the description carries the burden. It transparently discloses downscaling (maxWidth 512), native-resolution option (maxWidth 0), performance/cost rationale, and the still-vs-playback caveat. This provides valuable behavioral context beyond the 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?

The description is moderately long but every sentence earns its place: use case, selection method, output caveats, and defaults. It front-loads the core purpose with 'SEE what a composition actually looks like' and remains readable despite the detail.

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

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

With no output schema and no annotations, the description adequately explains return type (images), parameter defaults, and behavioral caveats. It leaves some details to the schema (e.g., timeoutMs) but covers the core usage envelope well, including the self-correct workflow.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning around maxWidth (fast/cheap, native resolution), comp selection (name/index/active), and underscores the still limitation. This enriches, rather than merely repeats, schema descriptions.

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

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

The description clearly states it renders composition frames to images for visual verification, using specific verbs like 'render' and listing concrete problem cases (clipped text, wrong colors, RTL shaping). This distinguishes it from siblings like inspect-comp (structured state) and other render tools.

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?

Explicitly says to use 'after edits' to catch visual issues, and gives examples of problems the DOM doesn't reveal. It also implies when_not_to_use by noting time-based effects differ from playback, but doesn't name alternative tools directly (though includeState references inspect-comp).

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

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

With no annotations, the description carries the burden. It discloses the dB unit, per-channel control, and keyframing capability, but it does not explain what happens if no level is provided, how left/right override level, or whether existing keyframes are replaced. This leaves gaps for a mutation tool.

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

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

The description is a single, concise sentence that front-loads the action and resource, then adds two key feature areas. Every word earns its place with no redundancy or filler.

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

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

Given the 100% schema coverage and absence of an output schema, the description provides a sufficient high-level overview for an agent to select and invoke the tool. It lacks explicit usage exclusions and edge-case behavior, but the combination with the detailed schema is adequate.

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

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

Schema coverage is 100%, with each property already described in detail (e.g., leftLevel 'overrides level for left channel', timeInSeconds sets a keyframe). The description adds no additional parameter semantics, so the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Set') with a clear resource ('audio levels (in dB) for an audio or AV layer') and scopes the behavior with 'per-channel control and optional keyframing'. This distinguishes it from sibling read tools like get-audio-info and other setters like set-effect-property.

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

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

The description implies when to use the tool (when adjusting audio levels) but provides no explicit alternatives or exclusions. It does not reference sibling tools or state when not to use it, leaving the agent to infer usage from context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Change' which implies mutation but does not disclose side effects such as whether unspecified properties are preserved, how duration changes affect existing keyframes, or whether changes are reversible. This lack of detail for a mutation tool is a significant gap.

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

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

The description is two short sentences that get straight to the point: what changes and how to select the comp. Every phrase earns its place, and there is no fluff or repetition of obvious details.

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

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

Given that the tool has six optional parameters and no output schema, the description adequately covers the core purpose and selection mechanism. It does not mention the width+height pairing constraint, but the schema covers this. While it lacks explicit side-effect warnings, the basic usage for an agent is sufficiently clear, though it could be more complete with behavioral notes.

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

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

The input schema provides descriptions for all six parameters, including the constraint that width and height must be set together and that compName/compIndex are alternative selectors. The description repeats these settings and adds the 'or active comp' selection context, which slightly reinforces the schema but adds no new syntax or behavioral details. With 100% schema coverage, the description's redundancy is acceptable but not additive.

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

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

The description opens with 'Change a composition's settings' which clearly identifies the action (change) and resource (composition). It enumerates the editable settings (duration, frameRate, width+height) and specifies comp selection via compName/compIndex or active comp, distinguishing it from create-composition and layer-focused tools.

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

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

The description provides clear usage context, indicating what can be changed and how to select the target composition. It implies this is for modifying existing compositions rather than creating them, but it does not explicitly exclude alternatives or state when to prefer other tools. Sibling tools like create-composition suggest the distinction, but the description itself lacks explicit when-not-to-use 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without revealing side effects, how the tool resolves target properties (propertyPath vs propertyName vs propertyIndex), or what happens when keyframeIndex is omitted. For a mutation tool, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the core purpose and optional capabilities. Every word is meaningful, with no redundancy or filler.

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

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

Given the tool's complexity (12 parameters, nested keyframeOptions), no output schema, and no annotations, the description is severely incomplete. It lacks workflow context, return behavior, or any explanation of how to effectively use the many parameters, leaving an agent without enough guidance to invoke the tool correctly.

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

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

All 12 parameters have schema descriptions (100% coverage), so the baseline is 3. The description adds no parameter semantics beyond mentioning graph interpolation and easy-ease controls, which are already encapsulated in the keyframeOptions object. It does not explain parameter relationships or priority.

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

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

The description clearly states the specific action 'Set an effect property keyframe' and mentions optional graph interpolation and easy-ease controls. This distinguishes it from sibling tools like set-effect-property (which sets without keyframing) and setLayerKeyframe (which targets layer properties rather than effect properties).

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

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

The description implies usage for animating effect properties over time, but provides no explicit guidance on when to use this tool versus alternatives such as setLayerKeyframe or set-effect-property. No exclusions or alternative tool names are mentioned.

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

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

No annotations are provided, so the description alone must disclose behavior. It only says 'set or keyframe' without detailing side effects, mutation risks, requirements, or behavior when omitted parameters are used. This is insufficient for a complex mutation tool.

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

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

The description is a single, concise sentence that front-loads the core action and target. Every word adds value and there is no filler.

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

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

Given the tool's complexity (13 parameters, nested keyframeOptions, no output schema), a one-sentence description is inadequate. It does not explain when keyframing occurs (e.g., via timeInSeconds), how targeting precedence works, or any constraints. The schema provides detailed parameter info, but behavioral context is thin.

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

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

Schema coverage is 100% and each parameter has a descriptive comment, so the baseline of 3 applies. The description adds minimal value by mentioning 'using name/index/path', which loosely aligns with effectName, effectIndex, and propertyPath, but does not deepen understanding beyond the schema.

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

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

The description clearly states the action ('Set or keyframe') and the target ('any property on an existing layer effect'), and specifies the addressing methods (name/index/path). This distinguishes it from sibling tools like apply-effect or setLayerExpression, though it could more explicitly contrast with set-effect-keyframe.

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

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

The description implies usage for modifying properties on existing layer effects but gives no explicit when-to-use guidance or mention of alternatives. It lacks exclusions or conditions, so it remains at an implied-usage level.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that expressions can be set or removed, but does not disclose side effects such as overwriting existing expressions, handling of invalid expressions, or whether the target property must exist. The removal behavior via empty string is only implied, not explicitly stated in the description itself.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose without any filler. Every word earns its place, making it highly concise and scannable.

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

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

Given the moderate complexity (4 required parameters, no output schema, no annotations), the description provides the essential purpose but leaves gaps around behavioral outcomes and edge cases (e.g., overwriting, error handling, prerequisites). The schema covers parameters well, but the lack of behavioral context makes the description only minimally complete for an agent to safely invoke the 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?

Since the schema already provides 100% coverage with clear descriptions for all four parameters, the description adds minimal extra semantic value beyond mentioning 'remove' in the summary. The schema describes expressionString's empty-string behavior effectively, so the description does not need to compensate for missing parameter details.

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

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

The description uses a specific verb ('set or remove') and resource ('expression for a specific layer property'), clearly distinguishing it from sibling tools like setLayerKeyframe (keyframes) and run-script (general scripts). It precisely conveys both the primary action and the removal capability.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. Usage context is only implied by the tool's name and purpose, but no explicit when-to-use or when-not-to-use guidance is given relative to siblings like run-script or setLayerKeyframe.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without revealing what happens if the optional 'value' parameter is omitted, whether existing keyframes are overwritten, or what the tool returns. This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence that directly states the core action without any filler or redundancy. Every word contributes to understanding.

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

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

Given no annotations, no output schema, and an optional 'value' parameter whose behavior is unexplained, the description is not complete enough for an agent to fully understand the tool's behavior. The schema covers parameter names and types, but the description fails to convey key contextual nuances such as keyframe overwriting or the significance of the optional 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?

The input schema already provides 100% coverage of parameter descriptions, so the baseline is 3. The description adds little beyond restating 'specific layer property' and 'given time,' and it fails to clarify the optional 'value' parameter, which is not included in the required list. However, since the schema handles most semantics, a 3 is appropriate.

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

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

The description uses a specific verb 'Set' with a clear resource: 'a keyframe for a specific layer property at a given time.' It clearly distinguishes from sibling tools like set-effect-keyframe by focusing on layer properties rather than effects.

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

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

The description provides no guidance on when to use this tool versus alternatives. There are related sibling tools such as set-effect-keyframe and setLayerExpression, but the description does not mention them or any exclusions, leaving the agent without explicit usage direction.

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

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

With no annotations, the description must carry the transparency burden. It discloses key behavior (create vs. modify, two shape input methods), but it does not explain what happens if both maskRect and maskPath are provided, nor does it mention error cases, coordinate assumptions, or side effects. This is acceptable but not rich.

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

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

The description is exactly two sentences, front-loaded with the primary purpose and following with essential usage. Every clause is informative, with no fluff or repetition of schema content. It is an model of concision.

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

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

For a tool with 12 parameters and no output schema, the description covers the central choices (shape type, add/modify) but omits mention of property parameters like maskOpacity, maskFeather, and maskExpansion, which are left to the schema. It also doesn't address edge cases or return behavior. Still, the essential usage is well-covered, so it's adequate but not exhaustive.

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 100%, establishing a baseline of 3. The description adds value by clarifying the OR relationship between maskRect and maskPath, a semantic not fully captured in the individual parameter descriptions. It also reinforces the maskIndex add/modify behavior, though this is already present in the schema. Overall, it provides a modest increment beyond structured definitions.

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

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

The description clearly states the tool's function: 'Create or modify a mask on a layer.' It names the specific resource (mask on a layer) and the actions (create/modify), which distinguishes it from sibling tools like setLayerKeyframe or setLayerExpression. The verb+resource combination is unambiguous.

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

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

The description provides actionable usage: 'Provide the shape as maskRect ... OR maskPath' and explains the distinction between adding and modifying via maskIndex. It does not explicitly mention when not to use this tool or name alternatives, but the context is clear for a mask-specific operation. This falls short of a 5 because it lacks explicit exclusionary 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?

No annotations are provided, so the description carries full responsibility. It discloses critical blocking behavior, AE UI unresponsiveness, timeout semantics, and post-timeout continuity. This is exemplary behavioral transparency.

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

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

Three sentences: purpose, important warning, and usage guidance. Every sentence earns its place with no filler, and the most critical information is front-loaded.

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 blocking operation with a single parameter and no output schema, the description covers the core purpose, operational impact, timeout behavior, and follow-up steps. It is sufficiently complete for an agent to invoke and handle the tool correctly.

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

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

Schema coverage is 100% for timeoutMs, and the schema already describes the parameter. The description adds practical context about when to raise the timeout and what happens if it expires, going beyond the schema's literal definition.

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

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

The description states a specific action ('Render all QUEUED items') on a specific resource ('After Effects render queue'), clearly distinguishing it from sibling tools like add-to-render-queue and render-queue. The scope is explicit, leaving no ambiguity about what the tool does.

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 provides explicit prerequisites ('Add items first with add-to-render-queue'), guidance on timeout handling ('raise timeoutMs for long renders; if the wait times out the render still continues'), and a clear alternative for checking status ('check status later with render-queue'). This fully informs when and how to use the tool.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'test', which is ambiguous—does it apply changes or remain read-only? It does not mention side effects, return values, or any safety profile, leaving the agent without critical information.

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

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

The entire description is one short sentence, which is appropriately concise in length, but it merely restates the tool name. This is under-specification rather than effective conciseness because it uses the sole sentence without providing any substantive 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 tool with no annotations, no output schema, and three required parameters, the description is wholly inadequate. It fails to explain what 'testing' means, how operation/comp/layer parameters interact, what the agent should expect as a result, or when this tool should be chosen over the many sibling animation tools.

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

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

The schema provides 100% description coverage for the three parameters, including the operation enum and brief guidance ('usually 1'). The description adds no parameter-level insight beyond the schema, so the baseline of 3 applies.

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 "Test animation functionality in After Effects" is a near-tautology of the tool name 'test-animation'. It identifies the domain (After Effects animation) but does not specify what testing entails, nor does it distinguish this tool from siblings like setLayerKeyframe or setLayerExpression.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools for setting keyframes and expressions, there is no explanation of whether this tool is for validation, comparison, or actual mutation, nor any exclusions or prerequisites.

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