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

No annotations are present, so the description carries the full behavioral burden, but it only restates the core action. It does not disclose side effects such as where the camera layer is placed in the layer stack, how it interacts with existing 3D layers or cameras, or what happens if a camera already exists.

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 eight-word sentence with no filler, leading with the verb and clearly stating the object and target. It is concise without being bloated, and any lack of detail is a completeness concern, not a structure concern.

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 mutation with only one required parameter and full schema coverage, the description is minimally adequate for invoking the tool. However, with no annotations and no output schema, it still leaves prerequisites, return/confirmation behavior, and side-effect context unstated.

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%: comp_name, camera_name, and preset all have descriptions, and preset also has an explicit enum and default. The description adds no extra parameter 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 uses a specific verb ('Add') and resource ('a camera layer to a composition'), making the core action unmistakable. Among sibling layer-creation tools like ae_add_text_layer, ae_add_solid_layer, ae_add_null_layer, and ae_add_light, it uniquely and clearly identifies what is created.

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 sibling tools, nor does it state prerequisites such as whether the target composition must already exist or be open. Agents must infer usage entirely from the tool name and schema.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not disclose whether adding an expression overwrites an existing one, what happens to keyframes on the property, whether invalid property paths or invalid ExtendScript produce errors, or whether the operation is reversible.

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 that front-loads the operation and contains no filler or redundant restatement of the schema. It is appropriately concise for a simple tool.

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

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

For a mutating tool with no annotations and no output schema, this description is too sparse. It omits behavioral outcomes and error conditions, leaving the agent to guess what happens to existing expressions or how success is indicated.

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 covers 100% of the parameters with useful descriptions, including examples for property_path. The description itself adds no parameter-level meaning beyond the schema, so it meets the baseline but does not exceed it.

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 'Add' and the resource 'an expression to a layer property', making the operation unambiguous. It is clear but does not explicitly differentiate itself from ae_set_layer_property or ae_remove_expression by naming them or explaining when expression-specific editing is appropriate.

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 prefer this tool over ae_set_layer_property, ae_run_script, or ae_remove_expression. There are no prerequisites, conditions, or exclusions mentioned; intended use is only implied by the tool name and sibling list.

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

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

With no annotations, the description carries the full burden of explaining side effects and mutation behavior, but it only states the basic action. It does not disclose whether an existing keyframe at the same time is overwritten, whether the property must already be keyframeable, or any error/return behavior.

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

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

The description is a single clear sentence with no filler or repetition. It is appropriately concise for a simple tool, though it does not enrich the schema in any way.

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 mutating tool with no annotations and no output schema, the description is sparse. It leaves unanswered important contextual details such as the effect of adding a keyframe to a non-keyframeable property, what happens on failure, and whether the operation replaces or inserts at the given time.

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

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

Schema description coverage is 100%, so all five parameters are already documented with meaningful descriptions. The tool description adds little beyond that, but since the schema handles the heavy lifting, a 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 clearly states a specific action ('Add a keyframe') and target resource ('a layer property at a specific time'). It is understandable and distinct from generic get/delete/interpolation tools, though it does not explicitly differentiate itself from the closely related sibling ae_add_keyframe_sequence.

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 about when to use this tool versus alternatives such as ae_add_keyframe_sequence, ae_set_layer_property, or ae_get_keyframes. The intended use is implied but not explicitly stated, and no exclusions or prerequisites 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 full behavioral burden. It only states the action and omits important behavior such as whether existing keyframes are overwritten, whether keyframes are sorted by time, how invalid properties are handled, or whether the operation is undoable.

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 one short, front-loaded sentence with no filler or redundant information. Every word earns its place, and the core purpose is immediately clear.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It does not explain what happens to existing keyframes, what the tool returns, or how it behaves on failure, which are important unknowns for an agent invoking a batch operation.

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 all four required parameters are already documented. The description adds no extra semantic detail beyond the schema, which is acceptable given the high 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 uses a specific verb and resource: it adds multiple keyframes at once to a layer property. It also clearly distinguishes itself from the sibling tool ae_add_keyframe by emphasizing the batch nature of the operation.

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

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

"Add multiple keyframes at once" implies the tool is for batch operations rather than adding keyframes one at a time via ae_add_keyframe. However, it does not explicitly state when to prefer this tool over alternatives or mention 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 of behavioral disclosure. It only states that a light layer is added, without mentioning side effects, required existence of the composition, default light behavior, or error handling. This is minimal rather than 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?

The description is a single clear sentence with no unnecessary words. It is concise and front-loaded, though it sacrifices informative depth for brevity.

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 mutating tool with seven parameters, no annotations, and no output schema, a one-sentence description is thin. The schema handles parameter details well, but the description does not explain what happens when the light is added or what the operation implies beyond the basic action.

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 every parameter documented and defaults provided. The description adds no parameter-specific meaning, 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 states a specific action and resource: 'Add a light layer to a composition.' This clearly distinguishes it from sibling tools like ae_add_camera, ae_add_text_layer, ae_add_solid_layer, ae_add_null_layer, and ae_add_shape_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 offers no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. An agent must infer the appropriate context solely from the tool name and the single sentence.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the basic action without revealing side effects, such as where the null layer is placed in the layer stack, whether it appears in rendering, or what happens if the composition already has a layer with the same name. This is a meaningful 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, front-loaded sentence with no wasted words. The main action and resource are stated immediately, and the control-layer clarification is included parenthetically without bloating the text.

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

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

For a two-parameter tool with no output schema and no annotations, the description is adequate but thin. It does not explain behavioral consequences or provide routing guidance, though the simplicity of the operation partially offsets this. An agent can call it correctly, but may miss important contextual expectations.

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 the target composition name and the null layer name. The description adds no further parameter-level semantics beyond echoing 'composition' and 'layer'.

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 ('Add'), resource ('null (control) layer'), and target ('a composition'), clearly distinguishing it from siblings like ae_add_text_layer, ae_add_solid_layer, and ae_add_shape_layer. The parenthetical 'control' adds useful semantic context.

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

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

The description implies usage when a null/control layer is desired, but it does not explicitly state when to prefer this tool over alternatives or mention any preconditions, such as the composition needing to exist. The guidance is implied by the resource type rather than stated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states the additive behavior 'Add a shape layer to a composition,' which is the core side effect. However, it does not mention requirements like an open project or existing composition, layer ordering behavior, default positioning, or failure 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, front-loaded sentence with no filler or repetition. It efficiently communicates the essential operation while leaving parameter details to the schema.

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

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

The description is adequate for the core creation action, and the rich input schema covers parameter meaning. However, with no annotations and no output schema, the agent gets no guidance about selection among sibling add-layer tools, no mention of required project state, and no indication of what a successful call returns.

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 92%, so the schema already documents nearly all parameters. The description adds only the relationship between the tool and the 'rectangle'/'ellipse' shape_type values, which is already an enum in the schema. No further parameter semantics are provided 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 names a specific verb ('Add'), a clear resource ('shape layer'), and the concrete shape types ('rectangle or ellipse'), all anchored to a target composition. This immediately distinguishes it from sibling tools like ae_add_text_layer, ae_add_solid_layer, and ae_add_null_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 gives no explicit guidance on when to choose this tool over alternatives, no exclusions, and no prerequisites. With many sibling layer-creation tools, the agent is left to infer selection purely from the tool name and the phrase 'rectangle or ellipse.'

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the mutation ('Add') without explaining side effects, layer placement, whether the layer is selected afterward, or any other observable project change. A creation tool benefits from describing what happens beyond the immediate action.

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 filler or redundancy. Every word contributes to stating the tool's purpose, making it efficient for an agent to parse.

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

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

Despite a complete schema, the absence of annotations, output schema, and operational context leaves gaps for a mutating AE tool. The description does not address what happens to the existing composition, whether the composition is created if missing, or what observable result the agent should expect. This makes the definition incomplete for reliable 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 the parameters are already well documented and the baseline is 3. The description adds minimal semantic context beyond what the schema provides, though 'solid color layer' does loosely connect the color and size parameters to the operation.

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

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

States a specific verb ('Add'), resource ('solid color layer'), and target ('composition'). It is clear and unambiguous, though it does not explicitly differentiate itself from sibling layer-creation tools such as ae_add_shape_layer or ae_add_null_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?

No guidance is given on when to use this tool versus alternatives like ae_add_text_layer, ae_add_null_layer, or ae_add_shape_layer. It also does not mention prerequisites, such as whether the target composition must already exist, leaving the agent to infer usage from the schema and sibling names.

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 restates the bare action and does not disclose failure behavior (e.g., nonexistent comp_name), where the layer lands in the layer stack, what font family is used, or whether the operation mutates and saves the project beyond the obvious. The core action is truthful, but behavioral context is essentially absent.

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 declarative sentence with zero wasted words, front-loading the verb and the object. Nothing could be removed without losing meaning, although the terseness does leave behavioral gaps that are penalized in other dimensions.

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 8 parameters, no annotations, and no output schema, so the description must compensate — but it covers neither return values nor edge-case behavior. It also does not explain meaningful context such as default position (960, 540) relating to composition dimensions or what happens when the target composition does not exist. For a mutating tool with no annotation safety net, the provided context is thinner than an agent needs.

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% — all 8 parameters (text, color channels, font_size, position_x/y, comp_name) have schema descriptions with types, defaults, and ranges. The tool description adds no parameter-level meaning beyond the schema, so the baseline 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?

States a specific verb ('Add') with a concrete resource ('a text layer') and destination ('to a composition'). The resource type clearly differentiates it from sibling add-tools like ae_add_solid_layer, ae_add_null_layer, ae_add_shape_layer, ae_add_camera, and ae_add_light.

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

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

No explicit when-to-use or when-not-to-use guidance is given, and no alternative tools are named. The usage context is only implied: an agent needing to place text in a composition can infer this is the right tool, but nothing helps disambiguate among the many ae_add_* siblings.

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

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

No annotations are provided, so the description carries the behavioral burden. It states only the literal action and leaves unstated whether rendering starts automatically, whether existing queue items are preserved, and how output_path is applied (e.g. creates an output module).

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

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

Single sentence, no filler, front-loaded with action. It is compact, though it sacrifices informational richness; conciseness itself is strong.

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 two-parameter append action, schema plus description is nearly sufficient, but missing context about queue workflow (e.g., use ae_start_render separately) and duplicate behavior. Given no annotations, there is a notable gap but not a fatal one.

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 already documents both comp_name and output_path at 100% coverage. Description adds no param-specific semantics, so baseline 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?

Description uses a specific verb ('Add') and resource ('composition ... render queue'), clearly indicating this queues a comp for later rendering. It is distinguishable from siblings like ae_start_render and ae_get_render_queue, though it doesn't explicitly disambiguate them.

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

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

No guidance on when to use this vs alternatives such as ae_start_render, ae_render_headless, or ae_clear_render_queue. Agent must infer that adding to the queue is a separate step from starting the render.

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 generic mutation 'apply an effect' and repeats the match-name mechanism; it does not mention side effects, error conditions, whether existing effects are replaced, or what happens on invalid input.

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 operation and includes a relevant example. There is no redundant or filler content, and it is appropriately sized for a simple tool.

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

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

The core call is fully specified thanks to three well-documented required parameters and no output schema. However, the description lacks prerequisite context, failure behavior, and any distinction from the batch sibling, making it only minimally complete.

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

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

Schema description coverage is 100%, so the baseline is 3 even without additional parameter explanation. The description adds only an illustrative example for effect_match_name that largely duplicates the schema's example, providing no meaningful semantic enrichment.

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 ('Apply an effect to a layer') and the identifying mechanism (match name), which is a strong verb+resource combination. However, it does not explicitly differentiate itself from the closely related sibling ae_batch_apply_effect, so it stops short of a 5.

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

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

No guidance is given for when to choose this tool over alternatives such as ae_batch_apply_effect or ae_run_script. The description implies a single-layer effect application use case, but it does not state exclusions, prerequisites, or when the batch variant would be more appropriate.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It only states that an effect is applied to layers and does not mention that this is a wide-reaching mutation, whether existing effects are preserved, how locked layers are handled, or what happens when no layers match the filter.

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 filler. Every word contributes to stating the operation and its scope.

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 mutation tool with no annotations and no output schema, the description omits important operational context: the potential for broad changes across a composition, no mention of success/failure behavior, and no guidance about the effect_match_name requirement being non-trivial. Schema coverage helps parameter semantics but does not fill this contextual 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?

Schema description coverage is 100%, so all four parameters are already documented in the input schema. The description only adds a passing reference to type filtering, which does not substantially improve parameter 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 states a specific action (apply an effect) and a specific scope (all layers, optionally filtered by type) within a composition. This clearly differentiates the tool from sibling ae_apply_effect, which targets a single 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 a batch use case, but it does not explicitly say when to choose this over ae_apply_effect or other sibling tools. The layer_type_filter parameter hints at usage scenarios, but no explicit when/when-not guidance is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that multiple compositions are created, but gives no details about batch failure behavior, duplicate name handling, whether the operation is atomic, or what happens to existing compositions. 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 one concise sentence with no wasted words and the core action is front-loaded. It could be slightly expanded to include behavioral guidance without becoming bloated, so it is concise but not fully fleshed out.

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 are no annotations and no output schema, the description is too sparse for a batch mutation tool. It does not explain return values, error semantics, project context requirements, or behavior on partial failure. The schema covers parameters well, but the description leaves important operational context unknown.

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 parameters. The description adds the useful framing that width, height, and frame_rate form a common template for all compositions, but it does not add syntax or format details 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 uses a specific verb ('create') and resource ('multiple compositions') and further clarifies that they share a common size/fps template. This clearly distinguishes it from the singleton sibling ae_create_composition and other batch operations.

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 use when creating multiple compositions with shared settings, especially versus ae_create_composition for a single composition. However, it does not explicitly state when to prefer this tool over alternatives or mention any 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the core import action and does not mention side effects, assumptions, failure behavior, or what happens to existing project items. For a mutating operation this leaves significant behavioral context undisclosed.

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

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

The description is one short sentence with no wasted words and front-loads the key purpose. It is concise, though it sacrifices useful usage context that could have been added without much bloat.

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

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

With a fully described schema and no output schema, the basic call can be constructed. However, the description lacks guidance on how this relates to the singular ae_import_file, what happens when sequence import is enabled, and what the expected result of a batch import is. It is adequate but not complete for a tool with no annotations.

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 fully documents all three parameters. The description adds no extra meaning about file_paths, destination_folder, or import_as_sequence, but the baseline of 3 applies because the structured schema carries the parameter documentation burden.

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 ('Import'), a clear resource ('After Effects project'), and a clear scope ('multiple files at once'). It distinguishes this tool from the sibling ae_import_file, which handles a single file, without needing to open the schema.

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 is for batch imports and implicitly contrasts with the singular ae_import_file, but it never explicitly states when to use this tool versus that alternative. No exclusions or conditions are provided, so the agent must infer the routing.

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

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

With no annotations, the description must carry the behavioral burden, and it only says 'Queue' without disclosing that the start_render parameter defaults to true, meaning rendering may begin immediately. It also does not mention whether the existing render queue is cleared, how errors are handled, or whether the operation is destructive.

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 filler. It states the core action and scope efficiently, leaving room for schema-level parameter 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 batch operation with no annotations and no output schema, the description is too thin to support correct invocation. An agent needs to know that start_render defaults to true, what happens to the existing render queue, and how the batch operation behaves if one job fails. These gaps materially affect whether the agent calls the tool safely.

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 documented in the schema. The description's 'multiple compositions' loosely maps to the jobs array, but it adds no extra semantic detail about comp_name matching, output_path requirements, or the output_template relationship.

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 ('Queue'), resource ('multiple compositions'), and outcome ('for rendering in a single operation'). It differentiates from singular tools like ae_add_to_render_queue through 'multiple' and from ae_start_render by framing the action as queuing, though it does not explicitly name any sibling.

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 'multiple compositions in a single operation' implies this tool is for batch rendering rather than single-item operations like ae_add_to_render_queue. However, there is no explicit when-to-use guidance, no mention of alternatives, and no 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 bears the full disclosure burden. It only says the tool sets a property value and gives no information about side effects, keyframe handling, prerequisites, or error behavior. For a mutation operation, this is a significant gap.

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

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

A single sentence with no wasted words. It front-loads the verb and resource, and the batch scoping is immediately visible. Nothing in the description is redundant with the schema.

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

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

With complete schema coverage and a clear purpose, an agent can invoke the tool correctly. However, there is no annotation, no output schema, and the description does not clarify behavior such as what happens when time is null vs set, whether existing keyframes are overwritten, or how missing layers are handled. These gaps limit completeness.

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 every parameter documented in the schema, including helpful details like the property_path example and the ['*'] wildcard for layer_names. The description itself adds no parameter-level meaning beyond the schema, so the 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 a specific action (Set) and resource (property value on multiple layers in a composition). The phrase 'multiple layers' and 'at once' distinguishes it from the sibling ae_set_layer_property, making the purpose immediately understandable and non-tautological.

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 context for when to use the tool: when a property needs to be set on multiple layers simultaneously. It does not explicitly name alternatives or exclusion criteria (e.g., 'for a single layer use ae_set_layer_property'), but the batch orientation is very clear from the wording.

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 behavioral burden, and it does: 'skips items currently rendering' is a non-obvious behavioral nuance beyond the destructive main action. It does not detail return values or confirm whether skipped items remain queued, but the main safety-relevant behavior is disclosed.

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

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

A single sentence conveys the action and the key exception with no filler. The main verb and object are front-loaded, and the parenthetical is tightly scoped to the one behavioral caveat.

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 zero-parameter, no-output-schema tool, the description is complete: it identifies the target, the scope, and the one edge case (currently rendering items). Nothing else is needed for an agent to invoke it correctly.

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

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

The tool takes zero parameters, so there is no parameter meaning for the description to add. Baseline 4 applies because the schema already fully covers the parameter surface.

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

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

States a specific verb (Remove) and resource (render queue) with the explicit scope 'all items', clearly distinguishing it from sibling ae_remove_render_queue_item which handles single items. The parenthetical adds a meaningful boundary to the operation.

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

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

The description implies use whenever the entire queue needs clearing, and the sibling list provides an alternative for single-item removal. However, it does not explicitly state when to choose this tool over ae_remove_render_queue_item or note any preconditions such as stopping renders first.

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, but it only names the action. It does not state what happens to unsaved changes when save=false, whether the application remains open, or whether the operation can be undone.

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 filler or repetition. 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?

The tool is simple, but a closing operation has meaningful consequences. The description plus schema does not fully cover what happens when save defaults to false, whether a project must be open, or the expected outcome, so it is minimally adequate rather than 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 the schema already documents the single save parameter and its default. The description adds no parameter-level meaning, matching 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?

The description uses a specific verb ('Close') with a clear resource ('the current After Effects project'), so an agent can distinguish it from related siblings like ae_open_project, ae_new_project, and ae_save_project. It directly states the operation and 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?

No guidance is provided about when to choose this tool over alternatives or what to do beforehand (e.g., saving via ae_save_project or setting save=true). The sentence states the action but leaves all selection and sequencing context implicit.

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

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

With no annotations provided, the description must carry the behavioral burden, and it only says 'Collect' without explaining whether files are copied or moved, whether the original project is modified, whether dependencies are included, or whether files are overwritten. The AE command analogy hints at behavior but leaves critical side effects unstated.

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 one sentence, front-loaded with the action and target, and the parenthetical analogy adds useful context without waste. Every part 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?

For an operation that writes multiple files to disk, the definition omits key context: success/failure behavior, whether the output folder is created or must already exist, whether original assets remain in place, and whether the project must be saved first. The absence of an output schema makes these gaps more significant.

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% and the one parameter, output_folder, is defined as 'Absolute path to the destination folder.' The description adds no extra semantics beyond this, but because the schema already covers the parameter, 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 a specific operation (collect assets) and a specific target (a single folder), and the AE 'Collect Files' analogy anchors meaning for users familiar with After Effects. It is distinct from siblings like ae_save_project or ae_export_frames, though it does not explicitly name or contrast alternatives.

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 about when to use this tool versus alternatives, no prerequisites, and no exclusions. It implies usage only through the stated purpose, but does not tell an agent whether to pick this over ae_save_project, ae_export_frames, or a folder-creation 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only names the action and context; it does not disclose what happens when no project is open, whether the new composition becomes active/selected, whether the operation is reversible, or any error behavior. The description adds little beyond what the tool name already conveys.

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 11-word sentence that front-loads the action and resource with zero wasted words. 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?

For a creation tool with no annotations, no output schema, and 6 parameters, the description is too thin. It omits prerequisites (an open project), expected side effects, failure conditions, and the existence of the sibling ae_batch_create_compositions for multi-comp creation. An agent cannot anticipate what happens when it invokes this tool.

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

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

Schema description coverage is 100%, with all 6 parameters (name, width, height, duration, frame_rate, pixel_aspect) already documented in the input schema. The description contributes no parameter-level 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 states a specific verb ('Create'), resource ('a new composition'), and scope ('in the current After Effects project'). The word 'new' plus the verb 'create' conceptually distinguishes it from nearby siblings like ae_duplicate_composition, ae_modify_composition, and ae_delete_composition, though it does not explicitly name any of them.

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 the many related siblings: ae_batch_create_compositions (bulk creation), ae_duplicate_composition (copying an existing comp), or ae_modify_composition (altering an existing comp's settings). The phrase 'current project' implies a prerequisite of an open project but never states 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?

No annotations are provided, so the description must disclose side effects itself. It confirms a mutating 'create' action, but does not say whether an open project is required, what happens if a folder with the same name exists, or what the function returns. It adds only the project-panel context, leaving key behavioral details to inference.

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

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

Single sentence, no filler, with the essential verb-resource-location structure front-loaded. Every word contributes to 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?

For a simple two-parameter creation tool, the schema covers parameter semantics well, but the description omits operational prerequisites such as needing an open project and error behavior for duplicate names or invalid parents. Without annotations or an output schema, an agent still has to infer some execution context.

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

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

Schema description coverage is 100%, and both parameters already contain clear descriptions in the schema. The tool description adds no extra semantic detail about the name or parent_folder parameters, so it meets the baseline but nothing more.

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

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

The description states a specific verb ('Create'), a specific resource ('folder'), and a specific location ('After Effects project panel'), cleanly distinguishing this from sibling layer/composition/project-item tools. No other sibling creates folders, so there is no 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 gives no guidance about when to choose this tool over alternatives, nor any prerequisites or exclusions. It does not mention that a project must be open or how this relates to folder organization workflows. This is essentially a statement of function, not 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It discloses irreversibility with 'permanently', which is important for a destructive operation, but it does not mention undo behavior, prerequisites, or consequences for project references.

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 filler. Every word contributes: the irreversibility, the action, the resource, and the scope.

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 one-parameter destructive operation, the description plus schema provide enough to select and invoke the tool correctly. It lacks edge-case detail such as behavior when the composition is not found, but the operation's low complexity makes this a minor 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 schema describes the sole parameter as 'Composition name to delete' with 100% coverage, so the description adds no new parameter-level meaning. The baseline of 3 applies because the schema already handles the semantics.

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

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

The description states a specific action (permanently delete), a specific resource (composition), and the scope (from the project). This clearly distinguishes it from sibling delete tools such as ae_delete_layer and ae_delete_project_item.

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 use case is implied: use this when the agent needs to remove a composition from the project. However, it does not explicitly call out alternatives or conditions, such as using ae_delete_layer for layers or ae_delete_project_item for generic project items.

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 makes the destructive nature and the 1-based indexing explicit, but it does not mention that deleting a keyframe shifts subsequent keyframe indices or what happens if the index is out of range.

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

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

A single, front-loaded sentence with no filler. Every word contributes to understanding the tool's core behavior.

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 minimally viable for a simple delete operation, and the schema covers all required parameters. However, since there are no annotations and no output schema, the description could usefully add edge-case behavior or note that deleting by index may invalidate previously-known keyframe indices.

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 documents all four parameters with 100% coverage, so the description does not need to repeat them. It adds a small amount of meaning by clarifying the keyframe index is 1-based, but it does not explain property_path syntax or other parameter nuances.

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

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

The description states a specific verb ('Delete'), a precise resource ('a specific keyframe from a layer property'), and the selection mechanism ('by index (1-based)'). This clearly distinguishes it from related sibling tools like ae_add_keyframe or ae_get_keyframes.

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 intended use is clear: remove a particular keyframe identified by its index. It does not explicitly discuss when not to use it or recommend alternatives, but the one-sentence context is enough to route an agent correctly among keyframe-related tools.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only restates the deletion operation and does not mention irreversibility, effects on dependent layers, expressions, or render queue references, or failure behavior for missing comps/layers.

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, efficient sentence with zero filler or repetition of schema fields. It front-loads the core action and is appropriately sized for such a simple tool.

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

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

Basic invocation is possible because both required parameters are fully documented and the operation is simple. However, for a destructive action with no annotations and no output schema, the description omits key context such as whether deletion is undoable, whether related layer data is removed, and what happens if the comp or layer is invalid.

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 with descriptions for both comp_name and layer_name. The tool description adds no additional semantic detail about parameter formats, relationships, or preconditions, 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 clearly states the action ('Delete'), the object ('a layer'), and the containing context ('from a composition'). This unambiguously distinguishes it from related siblings such as ae_delete_composition and ae_delete_project_item.

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 about when to use this tool versus alternatives, no exclusions, and no mention of prerequisites like an open composition. The only usage signal is the imperative description itself, which provides minimal context for selecting between this and similar deletion tools.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It only says 'Delete an item' without noting irreversibility, effects on compositions that reference the item, or any failure conditions. For a destructive operation, this is a significant transparency 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, clear sentence with no redundant words. The core action is front-loaded, and it is appropriately sized for the tool's simplicity.

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

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

For a one-parameter, no-output-schema tool, the description is minimal but adequate. However, it does not clarify what counts as an 'item' (e.g., folders, compositions), how the tool behaves if the item is in use, or name-matching rules. These gaps are notable for a destructive operation but not crippling given the simple interface.

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 the only parameter item_name described as 'Name of the item to delete.' The tool description adds the 'project panel' context but does not otherwise enrich parameter semantics beyond the schema. 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 states a clear verb and resource: 'Delete an item from the After Effects project panel.' It differentiates from sibling tools like ae_delete_layer and ae_delete_composition by specifying the project panel as the location. However, it does not clarify whether 'item' includes compositions, folders, or footage, leaving slight ambiguity alongside ae_delete_composition.

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 such as ae_delete_composition, ae_delete_layer, or ae_remove_render_queue_item. The description does not mention exclusions or conditions, so an agent must infer usage solely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Duplicate a composition' reveals the operation but says nothing about side effects (a new composition created alongside the original), error conditions (nonexistent comp_name, naming collisions), or what the tool returns. For a state-changing tool with zero annotation coverage, this is a significant gap.

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

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

The three-word description is undeniably concise and front-loads the key verb and resource. However, it is closer to under-specification than earned conciseness—it essentially restates the tool name and contributes no additional information that would justify its existence.

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 moderate-complexity mutation tool with no annotations and no output schema, the description is incomplete. An agent knows what to pass (from the schema) but not what to expect back, how failures are surfaced, or what state changes occur in the After Effects project. The schema covers inputs well but the description fails to cover the surrounding behavioral context.

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

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

Schema description coverage is 100%: both comp_name and new_name are documented in the schema itself, including the 'Copy of <name>' default for new_name. The description adds no parameter information, but per the baseline rule, 3 is appropriate when the schema already 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 a specific verb ('Duplicate') and resource ('composition'), which clearly identifies the operation. Because the sibling set includes ae_duplicate_layer, naming the resource as 'composition' meaningfully distinguishes this tool. However, it lacks any scope qualifier or explicit sibling differentiation, so it stops short of the best examples.

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

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

There is no guidance on when to use this tool versus alternatives such as ae_create_composition or ae_duplicate_layer. No prerequisites, exclusions, or conditions are mentioned, leaving the agent to infer selection solely from the tool's name.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the operation name. It does not explain whether the duplicate copies all properties, where the new layer is placed, how it is named, or whether the operation affects selections or subsequent actions.

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 filler or redundancy. While it is very terse, every word contributes to stating the core action and scope, though it omits useful behavioral context.

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

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

For a simple two-parameter operation, the description is minimally viable: it identifies the target composition and layer via the required parameters. However, it lacks detail about duplicate naming, placement, and whether effects/properties are copied, which an agent may need for downstream steps after duplication.

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 with descriptions for both comp_name and layer_name, so the baseline is 3. The description adds no additional parameter-level meaning beyond what the schema already states.

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

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

The description states a specific verb ('Duplicate') and resource ('layer within a composition'), clearly distinguishing it from sibling tools like ae_duplicate_composition, ae_delete_layer, and ae_rename_layer. There is no ambiguity about what operation is performed.

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, such as ae_duplicate_composition for copying compositions or ae_add_*_layer for creating new layers. There is no mention of exclusions, prerequisites, or preferred contexts.

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 discloses the core effect (smoothing all keyframes) but omits material side effects: it overwrites any existing per-keyframe interpolation on the property, and behavior when the property has no keyframes is unstated.

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 13-word sentence, front-loaded with the action and ending with a useful jargon-defining parenthetical. Every word earns its place with zero waste.

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?

Adequate for a simple batch operation with fully documented parameters, but gaps remain: no output schema or stated return value, no indication of behavior when the property has no keyframes, and no error/no-op semantics.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters, including the ease_type enum with its options. The description adds only the 'all keyframes of a property' context; 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?

States a specific verb and resource: applies Easy Ease to all keyframes of a property, with the parenthetical defining the AE jargon term. The batch 'all keyframes' scope distinguishes it from per-keyframe siblings like ae_set_keyframe_interpolation.

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 context is implied: this is the one-shot standard-easing convenience operation. However, it never names alternatives or states when not to use it, such as when per-keyframe interpolation control via ae_set_keyframe_interpolation is required.

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

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

No annotations are provided, so the description carries the full burden of explaining behavior. It only restates the operation and the AV-layer target; it does not disclose potential side effects, whether the operation toggles or strictly enables, whether existing keyframes are affected, or what happens on invalid layers.

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 filler words or redundant phrasing. It is appropriately compact for a two-parameter tool, though it could have included a bit more operational context without becoming bloated.

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

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

For a tool with no annotations and no output schema, the description is minimally viable: the action, target layer type, and required parameters are identifiable, and the schema covers the parameters fully. However, usage conditions and behavioral side effects are left unexplained, which is a clear 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 input schema already documents both parameters with 100% coverage, so the baseline for this dimension is 3. The description adds slight semantic value by indicating that layer_name should refer to an AV layer, but it does not meaningfully extend the schema's 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 uses a specific verb ('Enable'), a specific feature ('time remapping'), and a clear target ('an AV layer'), making the tool's purpose unambiguous. It also stands apart from many siblings like ae_set_layer_property or ae_set_layer_time because it names the exact operation being performed.

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

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

The description gives no explicit guidance about when to use this tool instead of alternatives such as ae_set_layer_property or ae_add_keyframe. It does not state prerequisites, conditions, or exclusions, so an agent must infer applicability purely from the tool name and the short action phrase.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the key side effect — frames are queued rather than rendered or written to disk — which meaningfully separates this from a direct export tool. However, it doesn't state how many queue items result (one per frame vs. a single sequence), whether existing queue items are cleared or affected, or that a subsequent ae_start_render call is required.

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

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

One 18-word sentence with zero filler. The verb and resource are front-loaded, and the destination qualifier ('to the render queue') precedes any subordinate detail. 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?

The schema is rich and the description states the core queuing outcome, but with no annotations and no output schema the description should also cover usage context and post-invocation expectations. An agent can invoke the tool correctly with schema help, but won't know what to expect afterward — queue contents, whether rendering starts, or the return value.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the description itself adds no parameter-level insight. The schema already documents all six parameters, including units (seconds), defaults (filename_prefix 'frame_', output_template 'Photoshop'), and example template values.

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

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

States a specific verb ('Export'), resource ('a range of frames from a composition'), destination ('to the render queue'), and output type ('as still images'). The 'range of frames' and 'still images' qualifiers distinguish it from sibling queue tools like ae_add_to_render_queue and ae_start_render without needing to inspect their schemas.

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 is a single declarative statement with no when-to-use guidance, no exclusions, and no mention of alternatives. With siblings like ae_add_to_render_queue, ae_set_output_module, ae_set_render_settings, and ae_start_render available, an agent receives no help deciding which tool fits the task.

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 behavioral burden. 'Get' accurately signals a read-only listing and there is nothing misleading, but the description does not disclose potential behavioral details such as error behavior when comp_name does not exist, ordering of layers, or whether the composition must be currently open.

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 filler or redundant information. 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?

The tool is simple, with one fully documented parameter, and the description states the core action. However, with no output schema and no annotations, the description does not clarify the return shape (e.g., layer names vs. full layer objects) or error conditions, leaving those details to runtime discovery.

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 fully documents comp_name (coverage 100%), so the baseline for this dimension is 3. The description adds no parameter-specific meaning beyond restating that a specific composition is targeted, which is acceptable but not enhancing.

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 clear verb and resource: 'Get all layers in a specific After Effects composition.' It is unambiguous about the operation, but it does not explicitly distinguish itself from closely related siblings like ae_get_layer_properties, so it stops short of full 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 intended use is implied: when an agent needs to retrieve all layers for a named composition. However, there is no explicit when-to-use guidance or mention of alternatives, so an agent is left to infer when ae_get_composition_layers should be preferred over ae_get_layer_properties or other layer tools.

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

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

The description discloses the return content by listing the kinds of settings included, which is useful since there is no output schema. However, it does not explicitly state that the operation is side-effect-free or describe error behavior, and with no annotations the description carries a heavier burden.

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, well-structured sentence that front-loads the action and object, then adds clarifying examples. Every word contributes value 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?

For a simple one-parameter getter with no output schema, the description provides sufficient context by listing common composition settings and signaling that more exist with 'etc.' It could be more exhaustive about exact return shape, but nothing critical is missing for an agent to invoke it correctly.

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

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

The input schema already provides a clear description for the single parameter comp_name ('Composition name') with 100% coverage. The description adds no additional detail about the parameter, so it stays at the schema-covered 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 and object: 'Get all settings of a composition', and enumerates concrete examples (size, fps, duration, bg color, work area) that make the tool's scope immediately clear. This clearly distinguishes it from siblings like ae_get_composition_layers or ae_get_project_info.

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 about when to use this tool versus alternatives such as ae_get_composition_layers or ae_get_project_info. The read-oriented name implies usage for reading settings, but there are no explicit conditions, exclusions, or suggested alternatives.

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

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

With no annotations, the description carries the behavioral burden. It signals a safe, read-only action and emphasizes 'all' keyframes, but it does not disclose the return format, what happens when there are no keyframes, or how keyframes with expressions are handled. 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 one short, front-loaded sentence with no filler. It efficiently conveys the core operation 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?

The tool is simple and all required parameters are documented, but there is no output schema and the description does not clarify the shape of the returned keyframe data or edge-case behavior. It is minimally sufficient for invoking the tool, but leaves some uncertainty about the result.

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

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

Schema description coverage is 100%, so the parameters are already documented with names, types, and examples. The description adds no additional parameter-level meaning beyond the schema, so a 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 states a clear action and resource: 'List all keyframes for a layer property.' It distinguishes itself from sibling tools like ae_add_keyframe, ae_delete_keyframe, and ae_set_keyframe_interpolation by making clear this is a read-only listing operation.

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

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

The intended use is implied: call this when you need to inspect the keyframes on a specific layer property. However, the description does not explicitly mention when not to use it or name alternatives, so the agent must infer the appropriate context from the tool name and siblings.

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

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

No annotations are provided, so the description carries the behavioral burden. 'Get' indicates a read-only operation and the scope is stated, but the description does not disclose what exact properties are included, how missing comps/layers are handled, or what the return shape is.

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

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

A single front-loaded sentence with no filler or repetition. 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?

For a simple two-parameter getter, the description covers the operation and scope. However, since there is no output schema, the return content is only broadly characterized as 'transform and basic properties'; enumerating fields would make it fully 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%, with comp_name and layer_name each documented as their name. The description adds no additional meaning 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?

Description uses a specific verb ('Get') and names the resource ('layer properties') plus scope ('current transform and basic properties'). It is clear enough to distinguish from ae_get_composition_layers and mutation tools like ae_set_layer_property, though 'basic properties' is somewhat vague and does not enumerate the exact fields returned.

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 about when to prefer this over sibling tools such as ae_get_composition_layers, nor any exclusions or prerequisites. The operation is inferable from the name, but the description does not state usage context or alternatives.

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

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

No annotations are provided, so the description carries the full burden. It indicates a read operation ('get'), but it does not describe error behavior when no project is open, what information is included, or any side effects. This leaves the agent without important behavioral expectations.

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, clear sentence with no filler. It front-loads the action and resource, and its brevity matches the simplicity of a parameterless query tool.

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

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

For a simple, parameterless query tool, the description is minimally adequate. However, with no output schema or annotations, it does not explain what information will be returned or how the tool behaves if no project is open, leaving some uncertainty for the 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 tool has zero parameters and the schema already fully documents this. There is no parameter burden for the description to carry, so the baseline of 4 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 states a specific action ('get information') on a specific resource ('currently open After Effects project'), which distinguishes it from sibling tools that target compositions, layers, or project items. However, 'information' is somewhat broad and could be more specific about what aspects of the project are returned.

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 about when to use this tool versus alternatives like ae_list_project_items or ae_get_composition_settings. The 'currently open' phrasing implies a precondition, but the description does not explicitly state when to choose this tool or what conditions must be true.

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, but it only states the pure function. It doesn't clarify what 'state' encompasses, whether the operation is strictly read-only with no side effects, what the return payload contains, or whether it reflects live queue data. The verb 'Get' weakly implies non-mutation, but the absence of any behavioral detail leaves the agent guessing.

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 11-word sentence with zero wasted text. The verb leads, the resource follows, and there is no redundant phrasing. For a parameterless getter, this level of economy is ideal.

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's complexity is low (0 params, no annotations, no output schema), which lowers the completeness bar. The description covers the basic purpose adequately. However, since there is no output schema, 'current state' is the agent's only clue about the return value, and it is ambiguous — the agent cannot predict whether it receives item names, statuses, progress percentages, or queue length.

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, so the description has nothing to add beyond the schema. Per the baseline for parameterless tools, 4 is appropriate — the schema already documents everything an agent needs about parameters (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 ('Get') and resource ('After Effects render queue'), making the tool's function clear. It distinguishes itself from render-queue siblings like ae_add_to_render_queue, ae_start_render, and ae_clear_render_queue, which perform mutations rather than reads. However, 'current state' is somewhat underspecified — it doesn't say whether that means queued items, their render status, progress, or settings.

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 usage guidance is provided. The description does not state when to use this tool versus alternatives, when not to use it, or how it fits into a render workflow (e.g., polling before/after ae_start_render). An agent must infer its role from the name and siblings.

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

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

There are no annotations, so the description carries the behavioral burden. It does disclose the target project and supported file types, which is useful context. However, it does not mention side effects such as whether duplicate imports are handled, whether the project must be open, or if an unsupported type will cause an error.

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. The core action, target, and file-type scope are all front-loaded and each 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?

For a one-parameter import tool, the description covers the essential invocation context: supported file types and the target project. It lacks guidance on error cases, batching alternatives, or success/return behavior, but the low complexity keeps this from being a critical 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?

Schema coverage is 100%, and the single parameter file_path is already described as an 'Absolute path to the file to import'. The description adds supported file-type context but no new parameter-level detail, 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 ('Import'), a clear resource ('a file'), and states the supported file types (video, image, audio, AEP) as well as the target context ('current After Effects project'). This clearly distinguishes the tool from sibling tools like ae_batch_import, which suggests batch behavior.

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

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

The description implies when to use it: when a single file needs to be brought into the current project. However, it does not explicitly mention alternatives like ae_batch_import for multiple files, nor does it state any 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?

There are no annotations, so the description carries the full burden. 'List' implies a read-only operation and 'current After Effects project' clarifies scope, but the description does not disclose the return structure, such as whether it returns names, IDs, or metadata, nor behavior in edge cases like no open project.

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, front-loaded with the verb and resource, and contains no filler or 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?

For a simple no-parameter tool, the core scope is stated clearly. However, with no output schema, the description does not specify what data is returned for each composition, leaving some ambiguity about the expected response shape and downstream tool selection.

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 zero parameters and schema description coverage is 100%, so there are no parameter semantics to clarify. The no-parameter baseline of 4 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 uses a specific verb ('List') and resource ('compositions') scoped to the current After Effects project. It is reasonably distinguishable from related siblings like ae_get_composition_layers and ae_list_project_items, though it does not explicitly name an alternative.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as ae_list_project_items or ae_get_composition_layers. It also does not mention prerequisites like having an open project, so usage context must be inferred rather than stated.

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

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

With no annotations, the description carries the disclosure burden; 'List' indicates a read-only operation and 'all available' states the scope. It does not clarify whether results include project-specific templates or what the returned structure looks like, but for a zero-parameter list tool this is a moderate 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?

One sentence with no filler; the verb, object, and context are front-loaded. 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?

For a no-parameter listing tool, the description states the resource and scope sufficiently for an agent to invoke it. The only missing context is the output shape, but since there is no output schema, a note about return format would have been a small improvement.

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 no properties and the tool takes zero parameters, so there is nothing the description must explain beyond the schema. The 0-parameter baseline applies here.

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') and a specific resource ('output module templates') in an After Effects context, so an agent can tell what the tool operates on. It does not explicitly contrast itself with the sibling tool ae_list_render_templates, though the resource name makes the distinction reasonably clear.

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 context is implied: call this when you need the set of output module templates. There is no explicit guidance about when to prefer it over ae_list_render_templates or how it relates to ae_set_output_module, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the full burden. It clearly states the tool is a read-only list operation and identifies the included item types, which is useful. However, it discloses no further behavior such as whether folders are recursively expanded, whether items are returned in project-panel order, whether hidden items appear, or whether the list is flat.

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 one sentence with no filler: verb, resource, scope, and item types all in a single line. 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?

For a parameterless read-only list tool, the description is basically adequate, but given generous sibling context and a large toolkit, it would benefit from clarifying scope details such as whether nested folder contents are included, how the result is ordered, and whether it overlaps with ae_list_compositions. No output schema exists, so a brief note on return shape would help.

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 coverage is 100% (the schema is empty). The description confirms there is nothing to configure, so parameter semantics are not a gap. Baseline for zero parameters is 4.

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' with a clear resource ('items in the After Effects project panel') and enumerates item types. It is distinguishable from siblings like ae_list_compositions, which lists only compositions, and ae_get_composition_layers, which lists layers within a composition.

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 states what the tool lists, but it does not explicitly say when to use this tool versus ae_list_compositions or ae_get_project_info. An agent can infer that this tool is the broad project-panel listing while siblings are more specific, but no direct guidance or exclusions are provided.

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

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

With no annotations, the description itself must convey behavior. 'List all available' indicates a read-only enumeration, but it does not disclose return format, edge cases such as no templates existing, or any side effects. This is adequate but leaves 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 sentence with no filler. Every word contributes meaning, and the key action and object are 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 simple zero-parameter list command, the description is nearly complete: it identifies the exact resource being listed. It could mention the return value shape, but the tool name and description make the result type evident enough.

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

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

The input schema has zero parameters, so there is nothing for the description to add. The baseline of 4 for zero-parameter tools is appropriate because no parameter clarification 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?

The description states a precise verb ('List') and resource ('render settings templates in After Effects'), which clearly identifies the tool's function. It also distinguishes from the sibling ae_list_output_templates by specifying 'render settings' rather than output templates.

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 ae_list_output_templates or ae_set_render_settings. It only restates the action without contextual cues 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, the description must carry the burden of behavioral disclosure. It clearly states this is a mutating operation on an existing composition and specifies which properties change. However, it does not disclose potential side effects, such as how changing dimensions or duration may affect existing layers, or whether changes are reversible.

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

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

A single, front-loaded sentence with zero filler. It opens with the verb and target, then parenthetically lists the exact settings, making the scope immediately obvious to an agent scanning the description.

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, the schema covers all parameters, and the description states the operation and target. It could mention the return value or any validation constraints, but nothing critical is missing for an agent to select and invoke this tool correctly among the many sibling composition tools.

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

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

Schema description coverage is 100%, so the schema fully documents each parameter, including units and role (e.g., 'New width in pixels', 'New duration in seconds'). The description merely lists the parameter names again without adding clarifying constraints or usage nuances beyond what the schema already provides. 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 uses a specific verb ('Modify') and resource ('settings of an existing composition'), and enumerates the exact settings affected (width, height, duration, frame rate, pixel aspect). It clearly distinguishes from creation tools like ae_create_composition and read tools like ae_get_composition_settings by emphasizing 'existing composition' and 'modify'.

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 appropriate usage: when an existing composition's basic settings need changing. It does not explicitly name alternatives or exclusions, but the context is clear enough, especially compared to sibling tools that create compositions or change specific settings like background color or motion blur.

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 burden of behavioral disclosure. It only states the action without mentioning whether the folder must already exist, whether references are updated, what happens on failure, or any side effects of the move.

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 clear sentence with zero filler. It is front-loaded and directly communicates the operation without 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 is simple with two well-defined string parameters, and the description is understandable. However, there is no annotation or output schema, and the description omits preconditions such as requiring an existing destination folder or an open After Effects project, leaving minor gaps in operational completeness.

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% and both parameters are already well described in the schema. The description adds minimal semantic value beyond 'move' and 'destination folder', but the schema already provides the necessary parameter meaning.

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

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

The description states a specific verb ('Move') and resource ('project item') with a clear destination ('into a folder'). It is distinct from sibling tools like ae_create_folder and ae_delete_project_item, so an agent can understand exactly what this 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?

The description provides no guidance about when to use this tool instead of alternatives such as ae_create_folder, ae_list_project_items, or ae_delete_project_item. There are no explicit conditions, exclusions, or references to related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the critical destructive side effect: 'closes the current one'. This is valuable transparency for a mutating operation. It could go further by noting that unsaved changes would be lost, but the core behavioral trait is disclosed.

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

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

A single sentence with zero superfluous words. The core action is front-loaded, and the crucial side effect is appended concisely in parentheses. 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?

For a zero-parameter tool with no output schema, the description adequately covers what the tool does and its most important consequence. It is slightly incomplete in that it does not mention whether unsaved changes are saved or discarded, or what the return value indicates, but these are minor gaps for such a simple operation.

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 coverage is 100%, so there is nothing for the description to clarify. Per the rubric, zero params warrant a baseline of 4. The description adds no parameter-specific detail because none 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?

The description uses a specific verb ('Create') and resource ('new blank After Effects project'), and the parenthetical 'closes the current one' clearly distinguishes it from siblings like ae_open_project, ae_close_project, and ae_create_composition. An agent can immediately tell this starts a fresh project rather than opening or creating a composition.

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 context is implicit: this is for starting a blank project from scratch, which is reasonably inferred from the wording. However, it does not explicitly state when to use this versus ae_open_project, ae_save_project, or ae_close_project, nor does it mention any prerequisites or exclusions. The guidance is present but only by implication.

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 restates that the tool opens a file; it does not disclose what happens to the currently open project, whether unsaved changes are affected, or what the tool returns after opening.

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 filler. Every word contributes to the tool's purpose and supported file types.

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

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

For a one-parameter open operation, the description is mostly sufficient, but with no annotations and no output schema, it leaves out what an agent should expect after invocation, such as whether the current project is replaced or what return value is provided.

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

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

The schema already documents file_path as an absolute path to the .aep file. The description adds value by specifying that both .aep and .aepx formats are supported, which is not stated in the schema, and by implying that the file must already exist.

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 and resource: 'Open an existing After Effects project file (.aep or .aepx)'. It clearly identifies the action and the file types, and the word 'existing' distinguishes this from creation-oriented siblings like ae_new_project.

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 the appropriate scenario: use it when an existing After Effects project should be opened. However, it provides no explicit exclusions or alternatives, such as noting that ae_new_project should be used for creating a project or ae_import_file for importing assets.

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

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

With no annotations, the description carries the full disclosure burden. It states the core operation and the key behavioral consequence — 'hierarchical transforms,' meaning the child inherits the parent's transform. However, it does not disclose side effects such as whether an existing parent assignment is silently replaced or whether the child's local transform is preserved after reparenting.

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

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

One 15-word sentence with zero filler. The operation is front-loaded ('Set the parent...'), and the purpose clause 'for hierarchical transforms' earns its place by explaining the behavioral rationale in a few 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?

For a low-complexity 3-param tool with no output schema and fully documented parameters, the description plus schema cover the operation, the special null case, and the purpose. Minor gaps remain: error conditions are undescribed and the description never explicitly states that the parent layer must reside in the same composition — but these are reasonable defaults for a tool this simple.

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%: 'Child layer name' and 'Parent layer name, or null to clear parenting' already document all three parameters, including the null-to-clear edge case. The description adds no param-level syntax or format details beyond what the schema provides, so it sits at the baseline 3.

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 and resource — 'Set the parent of a layer to another layer' — leaving no ambiguity about the operation. The parenthetical 'for hierarchical transforms' adds the rationale for the operation. Even among 70+ siblings, none other targets layer parenting, so it is clearly distinguishable.

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 'for hierarchical transforms' implies the use case: establishing transform inheritance between layers. However, the description never explicitly says when to prefer this over related siblings like ae_set_layer_property or ae_precompose_layers, nor when not to use it (e.g., for pure grouping without transform inheritance). The usage context is implied, not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the high-level action. It does not mention that precomposing typically modifies the source composition, replaces the selected layers with the new nested comp, or how attributes are affected, leaving an AI agent unaware of important side effects.

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

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

The description is a single, well-formed sentence with no filler or redundant detail. The key verb and object are front-loaded, and every word contributes to the 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?

The basic call is inferable from the schema and the one-line description, but the tool has no output schema and no annotations. Important context about side effects, return value, and behavioral constraints is missing, so the description is only minimally viable rather than fully 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 parameters are already documented. The description adds minimal semantic value beyond the schema, though 'new nested composition' loosely maps to new_comp_name and 'set of layers' maps to layer_names.

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

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

The description uses a specific verb ('Precompose') with a clear resource ('a set of layers') and outcome ('a new nested composition'). This uniquely identifies the operation among the large sibling list, and the result is concrete enough for an agent to know what will happen.

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 about when to use this tool versus alternatives such as ae_create_composition, nor any prerequisites, exclusions, or fallback conditions. The intended usage must be inferred entirely from the verb, so the description does not actively route the agent.

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 present, so the description carries the full burden of behavioral disclosure. It states the core mutation (expression removal) but does not mention what happens if no expression exists, whether the property value is affected, whether the action is reversible, or any error/permission implications.

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

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

A single, front-loaded sentence with no filler. It states exactly what the tool does and wastes no 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?

For a simple three-parameter removal operation with full schema coverage, the description plus schema is mostly sufficient for an agent to invoke it correctly. It is slightly incomplete because it omits edge-case behavior (no existing expression) and has no output schema, but these are minor for this tool.

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

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

Schema description coverage is 100%, so the parameter descriptions already document comp_name, layer_name, and property_path. The tool description adds no additional parameter semantics beyond identifying the target as a layer property, 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 states a specific verb ('Remove'), a specific object ('an expression'), and the scope ('from a layer property'). This clearly distinguishes it from sibling tools like ae_add_expression and ae_set_layer_property, so an agent can tell what it 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?

The verb and object imply the use case: call when an expression on a property needs to be removed. However, the description gives no explicit guidance about prerequisites, exclusions, or when to prefer related tools such as ae_add_expression or ae_set_layer_property.

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 behavioral disclosure burden. It clearly identifies the mutation and scope, but it does not mention irreversibility, behavior for an invalid index, or what happens if the item is currently rendering. Basic transparency is present, but edge-case behavior is absent.

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 with no filler. The verb, target, and selection mechanism are all present and front-loaded, making the tool's purpose immediately clear.

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

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

For a one-parameter removal action with no output schema, the description plus the input schema supplies the essential information needed to invoke the tool correctly. It does not describe return values, but that is a minor omission for such a simple destructive action.

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 the parameter already has a clear description ('1-based render queue item index'). The description adds no additional parameter meaning beyond restating 'by its index', so the baseline 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?

States a specific verb ('Remove'), a specific resource ('an item from the render queue'), and the selection mechanism ('by its index'). It is clearly distinct from sibling tools like ae_clear_render_queue and ae_get_render_queue.

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 wording 'by its index' implies the caller must first know the 1-based index, likely from ae_get_render_queue, but the description does not explicitly say when to use this tool or contrast it with alternatives such as ae_clear_render_queue for removing all items. Usage context is implied, not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core action and does not mention side effects, persistence, uniqueness requirements, or whether existing references to the composition are updated.

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

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

The description is short and front-loaded with no filler. It could be slightly richer, but the brevity is appropriate for a simple two-parameter rename operation.

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 absence of annotations and an output schema, the description is minimally adequate for a simple rename operation, but it leaves important context unstated: error conditions, duplicate name behavior, persistence, and what the tool returns after success. An agent receives little guidance beyond the schema.

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

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

The schema fully documents both parameters with clear descriptions ('Current name' and 'New name') at 100% coverage, so the baseline of 3 applies. The description adds no parameter-level meaning beyond what the schema already provides.

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

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

The description states a specific verb and resource: 'Rename a composition'. It is clear and distinguishable from sibling tools like ae_rename_layer and ae_modify_composition, though it does not add any context beyond what the tool name already conveys.

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 intended usage is implied by the verb and resource, but the description provides no explicit guidance about when to use this tool versus alternatives, nor does it mention exclusions. In a large sibling suite, an agent would benefit from a note like 'use ae_rename_layer to rename layers instead'.

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

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

Annotations are absent, so the description must carry the full behavioral disclosure burden. It only restates the rename operation and does not disclose effects on references, error behavior, or whether the rename is scoped solely to the given composition.

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 filler or redundant wording. It is appropriately sized for the simplicity of the operation and 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?

The description is minimally adequate for a simple three-parameter rename tool, but it omits important context such as what happens if the layer is not found, whether duplicate names are allowed, and whether renaming affects other compositions or expressions. Given the absence of annotations and an output schema, this is a noticeable 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?

Schema description coverage is 100%, with all three parameters already documented as 'Composition name', 'Current layer name', and 'New name'. The description adds little beyond confirming the operation context, so a 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 specifies a clear verb ('Rename'), a concrete resource ('a layer'), and the context ('in a composition'), so the operation is unambiguous. It also implicitly distinguishes this tool from siblings like ae_rename_composition by targeting layers rather than compositions.

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 about when to use this tool versus alternatives such as ae_rename_composition or ae_set_layer_property. There are no conditions, exclusions, or examples indicating the appropriate selection 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 behavioral disclosure burden. It usefully reveals that the render is headless and does not require After Effects to be open, but it does not disclose whether the call blocks until rendering completes, whether it returns progress/output, or what side effects occur beyond producing the output file.

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

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

Two concise sentences deliver the core purpose and the most important behavioral distinction without wasted words. The front-loaded 'Render a composition directly via aerender' immediately tells the agent what the tool does, and the second sentence adds a valuable clarification about After Effects not needing to be open.

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

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

For an 8-parameter tool with no output schema and no annotations, the description covers the key headless-render context but leaves out runtime behavior such as whether the command is synchronous, how completion is signaled, or what happens on render failure. The schema covers parameters, so the main gap is execution behavior rather than invocation details.

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% description coverage for all 8 parameters, so the schema already explains project_path, comp_name, output_path, frames, templates, and aerender_path. The description adds no parameter-specific meaning, but the baseline of 3 is appropriate because the schema handles 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 a specific action ('Render a composition') and the mechanism ('directly via aerender, command-line, no UI required'), which clearly differentiates it from UI-based siblings like ae_start_render and ae_add_to_render_queue. The added note that 'After Effects does NOT need to be open' reinforces the headless scope and removes 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 provides clear context for when this tool is appropriate: headless, command-line rendering without the After Effects UI. It does not explicitly name alternatives or exclusion criteria, but the 'no UI required' phrasing strongly implies the intended use case versus queue-based or UI-driven render tools.

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

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

With no annotations, the description carries the burden of disclosing behavior. It does reveal the core operation and the index convention ('1 = top'), which is helpful. However, it does not explain how other layer indices shift after the move, whether out-of-bounds indices are allowed, or whether the operation can fail for special layer states.

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 filler or redundant elaboration. Every word adds value, and the parenthetical index convention is essential for correct use.

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 three-parameter mutation tool with full schema coverage and no output schema, the description plus schema is largely sufficient for an agent to call it correctly. The main missing details are edge-case behaviors like index bounds and result confirmation, but these are not critical for basic 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 the schema already documents all three parameters adequately. The description adds only the layer-stack context and the '1 = top' convention, which is also already present in the schema's new_index description. This meets the baseline but adds no substantial new parameter meaning.

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

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

The description clearly specifies the action ('Move'), the object ('a layer'), and the target context ('in the layer stack'), making the tool's purpose immediately evident. It also distinguishes it from siblings like ae_delete_layer, ae_duplicate_layer, and ae_set_layer_property, none of which reorder layers.

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 layer-stack phrasing implies the tool is for changing z-order, which gives reasonable usage context. However, it never explicitly states when to prefer this over alternatives or mentions exclusions like locked/visible layers, so the guidance is only implicit.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. It clearly states that the operation mutates the footage item's source file and that all uses update automatically, which is valuable context. It omits failure-mode details like invalid paths or missing footage names, but the core behavior is 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, front-loaded sentence with no filler. Every phrase adds meaning: the action, the target, and the consequence are all covered 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?

For a simple two-parameter mutation with no output schema, the description provides enough context for correct invocation: it names the footage item parameter, the replacement path parameter, and the cascade effect on all uses. Edge-case behavior is not described, but that is not critical at this complexity level.

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 both parameters are already documented with meaningful descriptions. The tool description adds the concept of replacing the source file and automatic propagation, but it does not materially enhance the parameter-level semantics beyond what the schema already provides.

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

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

The description states a specific verb ('Replace'), a specific resource ('the source file of a footage item'), and a useful consequence ('all uses update automatically'). It is clearly distinct from sibling tools like ae_import_file or ae_delete_project_item, so an agent can identify when this tool is the right one.

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

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

The description makes the use case understandable: swap the source file of an existing footage item while preserving all uses. However, it does not explicitly state when not to use it or name alternatives, such as importing a new footage item instead.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It does not mention that executing arbitrary ExtendScript can mutate the project, has no undo, or may be destructive. It only states that the script runs and that the last expression is returned, leaving important safety behavior undisclosed.

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

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

The description is a single sentence with no filler, and the core action is front-loaded. Every word contributes to identifying the tool's function, making it highly efficient.

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

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

For an arbitrary-code-execution tool with no annotations and no output schema, the description is too thin. It does not mention when raw execution is appropriate, what the script can affect, or potential risks. The schema covers the return value, but the missing safety and usage context is a significant 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?

Schema coverage is 100% and the input schema already documents the script parameter and its return behavior. The description adds no additional parameter-level detail, so it correctly holds at the baseline of 3.

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

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

The description states a specific verb and resource: 'Execute a raw ExtendScript snippet directly in After Effects.' This distinguishes it from the many sibling tools that perform specific high-level operations, since it emphasizes raw, arbitrary script execution rather than a convenience wrapper.

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 about when to choose this tool over dedicated siblings, such as ae_apply_effect or ae_add_expression, nor are any exclusions or prerequisites mentioned. The raw/direct wording implies it is a generic fallback for scriptable operations, but this is not explicit.

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

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

No annotations are provided, so the description must carry the burden of disclosing side effects. 'Save' implies writing to disk, but the description does not state overwrite behavior, whether saving to a new path changes the project's working path, or what happens if no project is open. These are meaningful behavioral facts for a mutating operation.

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

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

The description is one short, front-loaded sentence containing exactly the essential action and resource. There is no filler, repetition, or 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?

As a simple one-parameter save command, the description is minimally viable, and the schema covers the output_path semantics. It is not fully complete because it omits behavioral consequences and explicit usage guidance, but the low complexity keeps this from being a severe 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 input schema fully documents the single parameter output_path with 'Optional: save to a new path. Null to save in place,' so parameter semantics are already well covered. The tool description adds no additional parameter context, which is acceptable given 100% 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 names a specific verb ('save') and a specific resource ('the current After Effects project'), making the tool's function unambiguous. No sibling tool covers project saving, so an agent can select this tool without inspecting other 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 command 'save the current After Effects project' implies the primary use case: persist the active project's current state. However, it gives no explicit guidance about when to save in place versus saving to output_path, nor does it contrast this with related operations such as collecting files or running scripts.

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 disclosing behavior. It only states that the tool sets the background color and does not mention whether the composition must already exist, what happens if comp_name is not found, or whether the new color overwrites the previous one; these gaps matter for an agent deciding whether the call is safe and what to expect.

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

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

A single, front-loaded sentence with no filler. It states the operation immediately and is appropriately sized for a simple setter tool.

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

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

For a simple setter, the description plus schema covers the core invocation details. Still, with no annotations or output schema, it would benefit from a note about expected behavior on invalid comp names, the default/overwrite behavior, or any return 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 documents all four parameters with descriptions, including the 0–1 ranges for color channels, so the description adds no new parameter semantics. Per the rubric baseline, this is adequate because schema coverage is 100%.

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 identifies a specific verb ('Set') and resource ('background color of a composition'), making the tool's intent unambiguous. It is distinguishable from sibling tools like ae_set_comp_motion_blur or ae_modify_composition, though it does not explicitly contrast itself with them.

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: call this when you need to change a composition's background color. However, the description gives no explicit when/when-not guidance and does not mention alternatives such as ae_add_solid_layer, which could also be used to create a background layer, so the agent is left to infer selection.

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 but does not disclose side effects, behavior when disabled, whether the composition must exist, or how the optional shutter_angle and shutter_phase interact with the enabled flag.

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, efficient sentence with no filler. The core action and target are front-loaded, which makes it easy for an agent to parse quickly.

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 is rich and covers all parameters, but with no annotations and no output schema, the description provides no context about preconditions, side effects, or optional parameter behavior. It is adequate for basic invocation but incomplete for fully informed 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 baseline of 3 applies. The description adds no parameter-level meaning beyond the schema, but the schema already documents all four parameters with types and ranges.

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 ('Enable or disable') and a specific resource ('motion blur for a composition'). It is unambiguous about what the tool does, though it does not differentiate itself from potentially overlapping siblings like ae_modify_composition or ae_set_layer_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 gives no guidance on when to use this tool versus alternatives. It does not mention sibling tools, exclusions, or preferred scenarios beyond the implied use of toggling composition-level motion blur.

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, but it only restates the action without explaining side effects, whether an existing keyframe is required, how in/out interpolation types interact, or what happens if the keyframe index is invalid. The mutating nature is implied by 'Set' 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 a single short sentence with no filler words, and the parenthetical '(easing)' adds helpful clarity. It is front-loaded and easy to parse, though slightly sparse for a tool with six 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?

Given no annotations, no output schema, and a mutating operation, the description is incomplete. It does not explain what success looks like, whether the keyframe must already exist, or how this relates to nearby sibling tools like ae_easy_ease_keyframes and ae_add_keyframe. More operational context is needed for an agent to invoke this confidently.

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

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

Schema coverage is 100%, so the schema already documents all six parameters, including the in_type and out_type enums and the 1-based keyframe_index. The description adds no extra parameter meaning, so the baseline score of 3 applies; it does not clarify ambiguous values like 'auto' versus 'auto_bezier'.

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

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

The description states a specific verb ('Set'), resource ('interpolation type (easing)'), and target ('a keyframe'), which is clear enough to understand what the tool does. It does not explicitly differentiate it from sibling tools like ae_easy_ease_keyframes, but the keyframe-specific focus helps distinguish it from add/get/delete keyframe 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 no guidance on when to use this tool versus ae_easy_ease_keyframes, ae_add_keyframe, or ae_set_layer_property. There is no mention of prerequisites, such as the keyframe already existing, or any indication of when this approach is preferred over alternatives.

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