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

With no annotations, the description carries the full behavioral burden. It does not say what happens to the previously active look, whether activation is reversible, what state it changes on the playback engine, or how errors surface when a name matches nothing. 'Activate' implies mutation but the details are 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?

It is a single front-loaded sentence with zero filler, which is structurally sound. The brevity, however, reflects under-specification rather than tight editing of rich content.

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 state-changing tool with no annotations and no output schema, the description is far too thin: it never explains the activation effect, return value, or failure modes. An agent would have to guess at the operational semantics before calling it.

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

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

Schema description coverage is 100%, including the cross-project search fallback for lookName, so the schema already documents parameters fully. The description's 'by name or ID' merely restates the two lookup modes without adding syntax, precedence, or conflict-resolution 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 states a specific verb+resource ('Activate a lighting look') that an agent can act on immediately. It fails to differentiate from the close sibling activate_look_from_board, so it stops short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites (e.g. whether cue playback must be running), and no routing to alternatives such as activate_look_from_board or get_current_active_look. 'By name or ID' hints at input options but says nothing about situational choice.

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

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

No annotations are provided, so the description carries the full burden. It helpfully discloses that the board's default fade time applies unless overridden, which is real behavioral context, but a state-changing action tool should also say what activation affects (live output), whether it supersedes a currently active look, or any prerequisites. Those gaps keep it at a 3.

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

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

A single short sentence with the action front-loaded and the one non-obvious behavioral nuance tucked into a parenthetical. Nothing wasted.

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

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

With no annotations, no output schema, and a fully documented param set, the definition is minimally serviceable. It tells the agent what the tool does and the fade default, but says nothing about the result of activation or how it interacts with playback state, which matters for an action 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 all three parameters are already documented in the schema, and the description's fade-time note merely echoes the fadeTimeOverride parameter. Baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb (activate) plus resource (a look) and scopes it to 'from a board', which meaningfully separates it from the sibling activate_look. It does not name that sibling explicitly, so an agent must infer the distinction, but the resource and scope are unambiguous.

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

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

The phrase 'from a board' implies this is the variant to use when the look lives on a look board rather than being activated directly, but there is no explicit when-to-use or when-not-to-use guidance and no mention of the alternative activate_look. Usage is implied 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 bears full behavioral burden and delivers almost none. It does not disclose whether inserting a cue renumbers/shifts existing cues, how position/referenceCueNumber interact with the required fields, permission requirements, or reversibility of the mutation.

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

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

It is a single front-loaded sentence with no filler, which is good. But the extreme brevity leaves the definition under-specified for a 10-parameter mutation tool, so it is concise without being appropriately sized.

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

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

For a 10-parameter write operation with no annotations and no output schema, the description is inadequate. Nothing explains the insertion semantics, the interaction between position, referenceCueNumber, and cueNumber, or what the caller should expect afterward.

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 10 parameters (including the before/after enum and the fade timings) are already documented in the schema. The description adds no parameter-level meaning beyond that, 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 clear verb and resource ('Add a new cue to an existing cue list'), which is enough to distinguish it from siblings like remove_cue_from_list. However, it never explicitly contrasts itself with alternatives such as bulk_create_cues, create_cue_sequence, or update_cue, so the differentiation is implicit rather than stated.

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

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

There is no guidance on when to use this tool versus bulk_create_cues, create_cue_sequence, or update_cue, and no stated preconditions (e.g., that the cue list must already exist). The 'existing cue list' phrasing faintly implies a prerequisite but nothing actionable is offered.

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

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

No annotations are provided, so the description carries the full burden. It hints at safe/additive behavior ('without affecting existing fixtures'), but there is a tension with the schema's overwriteExisting flag, and it says nothing about permissions, whether added fixtures are appended or merged, or ordering effects.

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

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

A single, tight sentence with the key scoping qualifier front-loaded and no wasted words.

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

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

For a mutation tool with no annotations and no output schema, the description is too thin: it does not clarify the effect of overwriteExisting, the return value, or how it differs from the many sibling look-mutation 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 already documents all three parameters including overwriteExisting and the nested channel values. The description's 'without affecting existing fixtures' loosely maps to the overwriteExisting default, but adds no syntax or format detail beyond the schema, 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?

States a specific verb ('add') and resource ('fixtures to a look') with a clear scope qualifier ('without affecting existing fixtures'). However, it does not distinguish itself from close siblings such as ensure_fixtures_in_look, copy_fixtures_to_looks, or update_look, so an agent must still infer which tool applies.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no mention of alternatives. With several overlapping siblings (ensure_fixtures_in_look, copy_fixtures_to_looks, remove_fixtures_from_look) present, the absence of routing guidance is a real gap.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it discloses only that placement is positional. It says nothing about what happens if the look is already on the board (error vs. duplicate), whether the caller needs ownership or write permissions on the board, or whether the operation is undoable given the undo/redo tooling present among siblings.

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 — verb, artifact, target, and placement constraint in one pass. Nothing is repeated from the name and no sentence fails to earn 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 mutation tool with no annotations, no output schema, and eight parameters, the description is too thin. It omits conflict handling, permission requirements, and the fact that required positioning parameters make this a layout-sensitive operation, all of which an agent needs before committing to a call.

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 one of the 8 parameters documented in the schema including defaults for width/height, so the schema does the heavy lifting and a baseline of 3 applies. The phrase 'at a specific position' loosely maps to layoutX/layoutY but adds no syntax, units, or constraint detail 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 names a specific verb (add), resource (look), and target container (look board) plus the resulting artifact (a button), so the operation is unambiguous. It does not, however, explicitly differentiate itself from close siblings such as bulk_create_look_board_buttons or update_look_board_button, leaving the agent to infer the singular-vs-bulk distinction from the name alone.

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

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

There is no when-to-use or when-not-to-use guidance. The description never mentions the alternative of bulk_create_look_board_buttons for adding multiple buttons, nor does it say whether this should be used instead of create_look_board_with_buttons when setting up a new board, so the agent receives no routing signal.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions 'analyze' but doesn't specify whether this is a read-only operation, what permissions are needed, if it's computationally intensive, or what the output format might be. For a tool with no annotations, this leaves significant behavioral 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, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded with the core functionality.

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 and no output schema, the description is incomplete for a tool that performs analysis. It doesn't explain what the analysis produces (e.g., a report, metrics, or visualizations) or any behavioral aspects like performance characteristics. For a 3-parameter tool with no structured support, this leaves too much unspecified.

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 thoroughly. The description doesn't add any additional meaning about the parameters beyond what's in the schema (e.g., it doesn't explain what 'cue list structure' entails or how recommendations are generated). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('analyze') and the target ('structure and timing of a cue list'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate this tool from sibling tools like 'optimize_cue_timing' or 'get_cue_list_details', which might have overlapping purposes in cue list analysis.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'optimize_cue_timing' (which might adjust timing) and 'get_cue_list_details' (which might retrieve basic info), there's no indication of when this analysis tool is preferred or what specific context it serves.

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 mentions 'analyze' and 'understand capabilities,' which suggests a read-only operation, but doesn't specify if it requires permissions, has rate limits, or what the output format is (e.g., textual report, structured data). For a tool with no annotations, this leaves significant gaps in understanding its behavior and constraints.

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 that front-loads the core purpose ('analyze specific fixtures') and adds clarifying detail ('to understand their lighting capabilities'). There is no wasted wording, repetition, or unnecessary elaboration, making it appropriately sized for its informational content.

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 complexity (analysis tool with 3 parameters), no annotations, and no output schema, the description is incomplete. It doesn't explain what 'lighting capabilities' means in practice, how results are returned, or any behavioral traits like error handling. For a tool that likely produces insights or reports, more context is needed to guide effective use by an AI 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?

Schema description coverage is 100%, so the schema fully documents the three parameters (analysisType, fixtureId, fixtureIds) with descriptions and an enum for analysisType. The description adds no additional meaning beyond the schema, such as explaining how 'fixtureId' and 'fixtureIds' interact or what 'lighting capabilities' entail. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('analyze') and resource ('specific fixtures'), specifying the purpose is to 'understand their lighting capabilities.' It distinguishes from siblings like 'get_fixture_inventory' or 'create_fixture_instance' by focusing on analysis rather than retrieval or creation. However, it doesn't explicitly differentiate from 'analyze_cue_structure' or 'analyze_script,' which might involve different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing fixture IDs from 'get_fixture_inventory,' or compare to siblings like 'analyze_cue_structure' for different analysis types. Usage is implied through the action and resource but lacks explicit context 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?

No annotations are provided, so the description carries the full burden. It never states whether the tool is read-only, whether it mutates the project, what the extraction produces, or how the boolean flags change behavior. For a 3-parameter analysis tool with no output schema, this 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 front-loaded sentence with no filler. It is efficient, though the brevity is partly under-specification rather than disciplined concision.

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

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

With no annotations, no output schema, and two behavior-altering boolean flags defaulting to true, the description should explain what the analysis returns and what each flag toggles. It explains neither, leaving the agent unable to predict the result or the side effects.

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

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

Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds nothing beyond a loose nod to 'lighting-relevant information' and does not explain the interaction between suggestLooks and extractLightingCues. 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 (analyze) and resource (theatrical script) with a clear output scope (lighting-relevant information). It is distinguishable from neighboring tools like analyze_cue_structure and analyze_fixture_capabilities by its input resource, though it does not name those siblings explicitly.

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

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

No when-to-use guidance, prerequisites, or alternatives are given. An agent cannot tell whether this is a first step before generate_act_cues or a standalone check, nor whether results feed anything else.

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

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

With no annotations, the description carries the full behavioral burden. "In a single operation" hints at batching, but it never says whether the batch is atomic (all-or-nothing) or partial on failure, how duplicate names are handled, or what permissions are required for a write. It merely restates the mutation implied by the name.

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 padding or repetition. It is efficient, though it is also the entire description, so there is no structure beyond the one clause.

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

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

No output schema exists and parameter documentation is fully in the schema, so those gaps are covered. However, for a mutation tool with zero annotation coverage, the description omits batch failure semantics and validation rules an agent would want before invoking it — minimum viable but not complete.

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

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

Schema description coverage is 100% and the nested item fields (name, projectId, description, loop) are all documented in the schema itself, so the baseline of 3 applies. The description adds nothing beyond the schema about the shape or requirements of the cueLists array.

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

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

States a specific verb and resource (create cue lists) plus the batching scope ("multiple... in a single operation"), which is the key distinction from the singular update_cue_list / delete_cue_list siblings. It does not name any sibling explicitly, but the bulk-vs-single intent is unambiguous.

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

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

There is no statement of when to use this over alternatives (e.g., why batch rather than calling a single-create path repeatedly, or how it relates to bulk_update_cue_lists / bulk_delete_cue_lists). No prerequisites, no exclusions, no routing guidance of any kind.

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, so the description carries the full behavioral burden. It discloses that everything goes in one GraphQL call, but says nothing about atomicity/partial-failure behavior, required permissions, rate limits, or validation rules for the nested cue objects.

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 short sentences, with the core action front-loaded and the batching rationale second. Nothing is wasted, though the second sentence is closer to an implementation note than decision-relevant 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?

Schema fully documents the single array parameter and there is no output schema to explain, but a mutation with no annotations should at least address failure semantics and prerequisites. Those gaps keep it at minimum-viable 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% and every nested field (name, cueNumber, lookId, cueListId, fade times) is documented in the schema. The description adds no syntax, format, or ordering detail beyond that, 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 and resource ('Create multiple cues') and the bulk nature is unambiguous, so an agent can separate it from single-cue tools like add_cue_to_list. It does not explicitly name which sibling to prefer, 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 on when to use this versus add_cue_to_list, create_cue_sequence, or the single-cue creation path. The only hint is the word 'bulk', leaving the agent to infer the selection condition 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 disclosure burden for a bulk mutation. It says nothing about permissions required, duplicate manufacturer/model handling, partial-failure semantics when one of many definitions is invalid, or whether the operation is transactional — all critical for a batch write.

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 tight sentences with the core action front-loaded and zero filler. Every clause 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 nested bulk-mutation tool with no annotations and no output schema, the description covers what the tool does but omits the behavioral detail an agent needs to call it safely — batch error behavior, duplicates, and what is returned on success.

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 nested fields (type, model, modes, channels, channel offsets, DMX min/max/default) are already documented in the schema. The description adds no format or constraint detail beyond it, 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 and resource: create multiple fixture definitions, with the parenthetical clarifying that a definition is a manufacturer/model combination. However, it never distinguishes itself from the close sibling bulk_create_fixtures (which presumably creates fixture instances rather than definitions), leaving the definition-vs-instance boundary implicit.

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

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

"Use this to efficiently add multiple fixture types... at once" implies the usage context is bulk insertion, but there is no explicit when-to-use vs bulk_create_fixtures, no guidance on single vs bulk, and no exclusions or prerequisites 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. It discloses the best-effort partial-failure model, per-fixture success/failure reporting, automatic DMX channel assignment, and pre-creation validation — substantive behavioral context for a mutation tool. It stops short of stating permissions, rollback semantics, or return format.

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

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

Four short sentences, front-loaded with the core action and failure model, each carrying a distinct behavioral fact. No filler or repetition.

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

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

For a single-parameter bulk mutation with no output schema, the description covers failure semantics, auto-assignment, and validation adequately. It lacks explicit guidance on error-recovery expectations and sibling routing, keeping it just shy of complete.

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

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

Parameter count is 1 and schema description coverage is 100%, so the schema already documents every nested fixture field. The description only adds that startChannel is optional ('auto-assign'), which the schema also states. 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 ('Create multiple fixture instances'), and the 'bulk' qualifier plus 'best-effort approach' distinguishes it from the singular create_fixture_instance sibling. An agent can select it without opening 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?

Implies batch use via 'multiple fixture instances' and 'partial success', but never explicitly says when to use this versus create_fixture_instance or bulk_update_fixtures. No when-not or exclusion guidance is given.

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

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

With no annotations, the description carries the full burden but only hints at batching via 'single operation.' It does not disclose whether the batch is atomic, what happens on partial failure, required permissions, or whether referenced boards/looks must pre-exist.

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

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

A single short sentence that is front-loaded with the verb and resource, with no filler. It is efficient, though arguably terse enough to leave necessary context unstated.

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 bulk mutation accepting an array of nested objects with required board/look references, the description omits failure semantics, ordering, and return behavior, and no output schema or annotations compensate. It is materially under-specified for the tool's complexity.

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

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

Schema description coverage is 100%, so the nested button object's fields are already documented in the schema. The description adds no meaning beyond the single 'buttons' array, 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?

The description states a specific verb ('Create') and resource ('buttons') and clarifies the bulk nature with 'multiple buttons in a single operation,' which distinguishes it from single-button operations. However, it does not differentiate from close siblings such as create_look_board_with_buttons or bulk_update_look_board_buttons.

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 create_look_board_with_buttons (for a new board) or add_look_to_board, nor any prerequisite such as the look board existing. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full burden. It does not disclose whether the batch is atomic or partially applied on error, who is authorized to create boards, or any rate/size limits — all critical for a bulk mutation.

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 short, front-loaded sentence with no filler. It is efficient, though its brevity is partly under-specification rather than disciplined conciseness.

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

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

For a bulk mutation tool with no annotations and no output schema, the description should explain at minimum error/partial-failure behavior and the shape of the result. None of that is present, leaving an agent unable to predict what a returned call means.

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 single lookBoards array parameter is self-documented with per-item name/projectId requirements and defaults for gridSize, canvas dimensions, and fade time. The description adds no further meaning beyond that 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?

States a specific verb (Create) and resource (look boards) plus the batch qualifier 'multiple ... in a single operation', which distinguishes it from the sibling create_look_board. It does not name that sibling explicitly, so it falls short of a 5.

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

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

No guidance on when to choose this over create_look_board or the other bulk siblings, no batch-size limits, and no prerequisites such as project existence or permissions. The agent must infer usage entirely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the return payload ('all created looks with their IDs'), which offsets the absent output schema, but says nothing about atomicity, partial-failure behavior, size limits, or permission requirements for a nested write 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?

Two short sentences, front-loaded with the action and followed by the return contract. No filler or redundancy.

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

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

For a deeply nested bulk-write with no annotations and no output schema, the description covers the action and return shape but omits error/atomicity semantics and any limits on batch size. 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 nested items, required fields, and DMX value bounds are already documented in the schema. The description adds nothing about parameter format or constraints, which is acceptable at full coverage but leaves it at the 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?

States a specific verb and resource ('Create multiple looks') and notes the batch nature ('in a single operation'). It does not explicitly distinguish itself from related siblings such as bulk_update_looks or generate_look, but the 'bulk create' framing and the 'multiple looks' scope are clear enough to select it.

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

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

There is no guidance on when to use this versus update_look, generate_look, or bulk_update_looks, and no prerequisites are stated despite each look requiring a projectId. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden for a write operation. 'Single operation' vaguely gestures at atomicity without saying whether a partial failure rolls back, how duplicate names are handled, or what identifiers come back — none of which is covered anywhere else.

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

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

A single front-loaded sentence with no filler or redundancy, and the bulk nature is stated immediately. It is efficient, though its brevity is partly the under-specification flagged elsewhere rather than disciplined density.

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

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

For a batch mutation tool with zero annotations and no output schema, the description leaves critical gaps: response shape, atomicity/partial-failure behavior, and practical batch limits. An agent can attempt the call but cannot predict what happens on partial failure.

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 name, groupId, and description are already documented inline; baseline 3 applies. The description adds only the notion of cardinality ('multiple projects'), which is marginally useful but not meaningful semantic detail.

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

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

States a specific verb (Create), resource (projects), and the bulk scope ('multiple projects in a single operation'), which cleanly separates it from the singular create_project sibling. It does not name that sibling explicitly, so an agent still has to infer the routing choice.

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

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

There is no when-to-use guidance, no statement of when to prefer this over repeated create_project calls, and no mention of batch size limits or prerequisites. The word 'bulk' plus 'multiple' implies batching, but nothing tells the agent when this is the right tool.

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

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

With no annotations, the description carries the full disclosure burden. It usefully implies non-atomic, partial-success behavior by mentioning 'any failed IDs', which is real behavioral signal, but it never states that deletion is irreversible, what permissions are needed, or that confirmDelete must be true for the call to proceed.

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

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

Two sentences, zero filler, with the operation and its scope front-loaded before the return-value note. Every sentence 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?

There is no output schema, so the description correctly compensates by describing the return shape (count plus failed IDs). For a destructive bulk tool with no annotations it could still warn about irreversibility, but the partial-failure semantics and return format are covered.

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 cueListIds and confirmDelete are already documented in the schema; the description adds no param-level syntax or format detail. Baseline 3 applies since the schema does the heavy lifting.

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

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

The description states a specific verb (Delete) and resource (cue lists) with explicit scope ('multiple ... in a single operation'), which implicitly separates it from the singular delete_cue_list sibling. It stops short of naming the single-item alternative directly, so it is clear but not fully differentiated.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of the single-item delete_cue_list alternative or the confirmDelete precondition beyond what the schema already states. Usage is only implied by the 'bulk' prefix and the plural resource.

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 does state the return format (count of successful deletions and failed IDs), but it does not disclose that deletion is destructive, whether it is reversible, or whether undo is available—critical omissions for a delete 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?

Two sentences, front-loaded with the core action, and no wasted words. The return-value note is secondary but directly relevant.

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

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

The description covers the action and return summary, and the schema fully documents parameters. However, for a destructive bulk tool with no annotations and no output schema, it should provide more safety context (e.g., irreversibility, confirmation requirement beyond the schema) and guidance on alternatives.

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 schema already documents both parameters ('cueIds' and 'confirmDelete') clearly. The description adds no additional parameter meaning beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description states a specific verb ('Delete'), resource ('cues'), and scope ('multiple cues in a single operation'). This clearly distinguishes it from sibling bulk-delete tools that target other resources like projects, looks, or cue lists.

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 cues in a single operation' implies this is for bulk deletion, which is useful context. However, it does not explicitly say when to use this tool versus a single-cue deletion alternative, nor does it mention 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?

With no annotations, the description carries the full behavioral burden. It does add genuine value by disclosing non-atomic, partial-failure semantics ('any failed IDs'), which is not derivable from the schema, but it omits irreversibility, permission/auth requirements, and any batch-size limits for a destructive 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?

Two tight sentences with zero filler; the action and its return contract are front-loaded in that order. Nothing in the text is redundant.

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

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

The absence of an output schema is partly offset because the description states the return shape (deleted count plus failed IDs). However, for a destructive bulk tool with no annotations at all, more disclosure about irreversibility and the confirmDelete safeguard's effect would be needed to be 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 description coverage is 100%, and both fixtureIds and the confirmDelete safety flag are fully documented in the schema itself. The description adds no format, ordering, or limit detail beyond that, 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?

The description states a clear verb ('Delete') plus resource ('fixture instances') and scope ('multiple ... in a single operation'), which distinguishes it from the singular delete_fixture_instance sibling by implication. It stops short of explicitly naming that alternative, so it is clear but not maximally disambiguating.

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 'in a single operation' implies this is the batch-efficient path versus deleting one at a time, but the description never states when to prefer it over delete_fixture_instance or bulk_update_fixtures. Usage must be inferred from the name and the word 'multiple'.

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 state that deletion is irreversible, what happens to buttons still referenced by a look board, or what the response contains. The safety confirmation flag is only visible in the schema, not explained here.

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

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

A single front-loaded sentence with no filler. It is efficient, though possibly too terse given the destructive nature of the 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?

For a two-parameter destructive mutation with no annotations and no output schema, the description is thin. The schema covers the confirmation requirement, but irreversibility and side effects on referencing look boards are never addressed.

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 (buttonIds, confirmDelete) are already documented inline, including the safety rationale for confirmDelete. The description adds no additional meaning beyond the schema, which is the expected baseline for full 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 states a specific verb ('Delete') and resource ('buttons'), with the bulk scope made explicit by 'multiple ... in a single operation'. It is clear enough to distinguish from single-button deletion and from the sibling bulk_delete_look_boards, though it does not 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?

There is no guidance on when to use this versus deleting buttons individually, updating them via bulk_update_look_board_buttons, or other bulk operations. No prerequisites or conditions are stated.

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

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

No annotations are supplied, so the description carries the full behavioral burden for a destructive bulk operation. It discloses only that multiple boards go in one call; irreversibility, permission requirements, cascade effects on buttons or cue references, and the confirmDelete safety gate (left to the schema) are all 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 front-loaded sentence with no filler or redundancy. It is efficient, though so terse that it borders on under-specification rather than optimal density.

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

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

For a destructive multi-record operation with no annotations and no output schema, the description should cover at least reversibility and failure behavior. Neither is present, leaving an agent unable to predict the consequences of the call.

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 (lookBoardIds, confirmDelete) are already documented in the schema, including the safety semantics of confirmDelete. The description adds no syntax, limit, or behavioral detail beyond that 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?

States a specific verb (delete) and resource (look boards) with an explicit bulk scope, which cleanly separates it from the singular delete_look_board sibling. It stops short of naming that sibling or any alternative, so an agent must infer the distinction.

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

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

No when-to-use guidance is given: nothing says when to prefer this over delete_look_board, whether the operation is atomic across IDs, or what happens on partial failure. The bulk intent is implied by the name and description only.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful trait: partial-failure semantics via 'count of successfully deleted looks and any failed IDs'. However it omits irreversibility/recoverability, permission requirements, and any mention of the confirmDelete safety gate beyond what the schema already 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?

Two short sentences, zero filler, with the operation and its scope front-loaded before the return-value note.

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

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

It usefully compensates for the absent output schema by describing the return payload, but for a destructive mutation with no annotations it should also address reversibility and the confirmDelete requirement to be fully self-sufficient.

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

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

Schema description coverage is 100% and both parameters (lookIds, confirmDelete) are documented in the schema itself, so the baseline is 3. The description adds no format, limit, or ordering semantics for lookIds beyond what the schema 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?

States a specific verb (delete), a specific resource (looks), and the bulk scope (multiple in a single operation), which cleanly separates it from bulk_delete_projects, bulk_delete_cues, and single-item delete_look.

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

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

There is no when-to-use guidance: it never says to prefer this over repeated single deletions, nor mentions the confirmDelete prerequisite, nor names any alternative tool. The reader must infer all routing decisions from the name alone.

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

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

With no annotations, the description carries the full burden. It usefully discloses partial-failure semantics by stating the return includes a success count and failed IDs, which implies operations may partially succeed. However, it says nothing about irreversibility, required permissions, or whether deletion is atomic.

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 tight sentences with zero waste; the operation is front-loaded and the return contract follows immediately. Every clause 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 destructive bulk tool with no annotations and no output schema, the description covers purpose and return shape well. It still leaves the irreversibility/permission profile unstated, which matters for an unflagged bulk delete, so it is not 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 description coverage is 100%, so both parameters (projectIds, confirmDelete) are already documented in the schema, including the safety rationale for confirmDelete. The description adds no syntax or semantic detail beyond what the schema provides, 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 (delete) and resource (projects) with clear bulk scope ('multiple projects in a single operation'), which implicitly distinguishes it from the singular delete_project sibling. It does not explicitly name an alternative, so the differentiation requires a small inference.

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 over delete_project or any alternative, and no stated preconditions beyond the schema's confirmDelete flag. The agent must infer usage entirely from the name and scope.

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

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

With no annotations, the description carries the full behavioral burden for a mutation tool, and it discloses almost nothing. It never states whether the bulk update is atomic or permits partial failure, what happens to invalid cueListId values, whether omitted fields are left untouched, or what permissions are 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?

A single front-loaded sentence with no wasted words, which is structurally ideal. It is arguably too terse for a bulk mutation tool, but it earns its place and reads cleanly.

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 bulk write tool with no annotations and no output schema, the description should at minimum address atomicity, partial-failure semantics, and what the caller gets back. None of that is present, leaving meaningful gaps for safe 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 cueListId, name, description, and loop are already documented in the schema. The description adds no syntax, format, or semantic detail beyond what the schema provides, 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?

States a specific verb+resource ('Update multiple cue lists') and implies the bulk scope via 'multiple', which distinguishes it from the singular sibling update_cue_list. It does not, however, name the sibling it is not, so differentiation is left implicit.

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

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

No guidance on when to use this versus update_cue_list or bulk_create/bulk_delete_cue_lists, and no preconditions or exclusions stated. The 'single operation' phrasing hints at a batching benefit but never says when batching is appropriate.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it does very little. It does not explain that this is a mutating operation that overwrites existing timing values, what happens to cues whose IDs are invalid, whether the update is atomic across all cues, or what permission/undo implications exist. Only neutral timing language is offered.

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

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

A single front-loaded sentence with no filler and no redundancy, which is efficient. It is brief almost to a fault, but nothing in it fails to earn 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 bulk mutation tool with zero annotations and no output schema, an agent still lacks key context: whether updates apply uniformly to all cueIds, error/partial-failure behavior, and confirmable side effects. The one-line description is not sufficient to call this 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 schema already documents all six parameters with units and behavior (e.g. followTime 'null to remove auto-follow'). The description adds no syntax, format, or constraint detail beyond what the schema provides, 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 (Update), resource (cues), and scope (multiple cues in a single operation), which lets an agent distinguish it from the singular update_cue and from bulk_create_cues / bulk_delete_cues. However, it advertises only 'fade times and follow times' while the schema also supports skip status and easing type, so the stated purpose is narrower than the tool actually is.

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 multiple cues in a single operation' implicitly signals the batch use case versus single-cue update_cue, but there is no explicit when/when-not guidance and no named alternative. Usage is inferable from the wording rather than stated.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the key trait that updates are atomic ('All updates succeed or fail together'). However it omits whether unlisted fields are left untouched vs cleared, permission requirements, and any error/response behavior, leaving meaningful gaps for a mutation tool.

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

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

Three short sentences, front-loaded with the core purpose and atomicity before the use-case examples. No filler, every sentence contributes.

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 covers purpose and atomicity but leaves partial-update semantics (whether omitted fields are preserved) and permission/error behavior unstated. Adequate but not complete for the risk profile.

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 nested fields (name, tags, layoutX/Y, universe, startChannel, etc.) are all documented in the schema. The description adds no parameter-level meaning beyond what the schema provides, 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 ('Update') and resource ('multiple fixture instances') and adds the distinguishing batch scope ('single atomic operation'). This lets an agent separate it from the singular update_fixture_instance without opening the schema, though no sibling is named explicitly.

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

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

It gives clear usage context ('batch renaming, repositioning, or re-tagging'), which tells the agent when this batch tool is appropriate. It does not state when NOT to use it or point to update_fixture_instance for single-item edits, 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?

No annotations are provided, so the description carries the full burden. 'Update' implies mutation but nothing is said about whether the batch is atomic, what happens on partial failure, whether fields are merged or replaced, or what permissions are needed. For a bulk write tool this is a significant gap.

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

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

A single front-loaded sentence with zero waste. It is efficient, though the terseness contributes to the overall under-specification of a mutating batch 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?

For a batch mutation tool with no annotations and no output schema, the description is too thin. It omits atomicity, partial-failure behavior, and result reporting, which an agent needs before invoking a bulk write.

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 array items are self-documenting (buttonId required, plus color/label/width/height/layoutX/layoutY), so the schema does the heavy lifting. The description adds no meaning about how updates are applied per item, so baseline 3 is appropriate.

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

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

States a clear verb (Update) and resource (multiple buttons) with a batch scope qualifier. It implicitly distinguishes itself from the singular update_look_board_button and from the create/delete bulk siblings, but never names them explicitly.

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

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

Provides no when-to-use guidance, no prerequisites, and no mention of alternatives such as update_look_board_button for single edits or update_look_board_button_positions for layout-only changes. Usage is only implied by the word 'multiple'.

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

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

No annotations are provided, so the description carries the full behavioral burden and it discloses almost nothing. It does not say whether the batch is atomic or per-item, what happens to fields omitted from an item, whether existing values are overwritten, or what permissions are needed for a mutation.

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

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

A single efficient sentence with no filler, front-loaded on the verb and resource. It is arguably too terse for a mutation tool, but there is no wasted wording to trim.

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

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

For a batch mutation with no annotations and no output schema, the description leaves critical agent-facing questions unanswered: atomicity of the batch, failure semantics, and whether partial success is possible. The schema covers the inputs, but nothing covers behavior on 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% and the nested lookBoards array documents all seven updatable fields, so the schema does the heavy lifting. The description only adds the notion of multiplicity, which the parameter name already conveys, 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 and resource ("Update multiple look boards") and the modifier "in a single operation" distinguishes it from the single-item update_look_board sibling. It does not, however, name any sibling explicitly, so an agent must infer the bulk-vs-single relationship from the name alone.

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

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

The description gives no when-to-use guidance, no conditions for preferring this over repeated update_look_board calls, and no mention of the related bulk_create_look_boards or bulk_delete_look_boards tools. Usage is only implied by the plural "multiple".

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, yet it says nothing about the key semantic question: whether omitted fields are left unchanged or cleared (critical when a 'partial' sibling exists). It also omits failure handling for a batch of look updates, permission requirements, and 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?

Two compact sentences with no filler, and the core action is front-loaded. It is efficiently sized, though the second sentence is close to restating schema fields.

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

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

For a batch mutation tool with no annotations, no output schema, and an ambiguous relationship to bulk_update_looks_partial, the description is too thin. An agent cannot determine merge semantics, partial-failure behavior, or which sibling to choose.

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 looks, lookId, name, description, and the fixtureValues/channels structure, making a baseline of 3 appropriate. The description adds only a field enumeration that largely mirrors the schema and does not clarify merge-vs-replace semantics for the nested fixtureValues.

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 ('Update multiple looks in a single operation') and enumerates the updatable fields (name, description, fixture values). It is clear what the tool does, but it never distinguishes itself from the near-identical sibling bulk_update_looks_partial or from single-look update_look/update_look_partial.

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

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

There is no when-to-use guidance, no prerequisites, and no routing to alternatives. Given the presence of update_look, update_look_partial, and especially bulk_update_looks_partial, the agent is left to guess which bulk variant applies.

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

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

With no annotations, the description carries the full burden and does disclose the key merge-vs-replace semantic. However, it says nothing about permissions, reversibility, atomicity, or what happens when one look in the batch fails — material for a bulk mutation with zero annotation coverage.

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

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

Three tightly written sentences with the core operation front-loaded and no filler. The final use-case sentence is helpful rather than redundant, though the definition is slightly longer than strictly necessary.

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 covers the merge semantics but omits error/partial-failure behavior and permission requirements. Adequate to invoke correctly, but not 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 baseline is 3, but the description adds real meaning beyond the schema by explaining what mergeFixtures=true actually does to unmentioned fixtures and enumerating the per-look fields. This exceeds what the field descriptions alone convey.

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 (update), resource (multiple looks), and scope (partial fixture merging), and explicitly distinguishes itself from bulk_update_looks. An agent can tell it apart from update_look, update_look_partial, and bulk_update_looks without opening any 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?

Names the alternative (bulk_update_looks) and the exact condition that selects this tool: preservation of existing fixtures when mergeFixtures=true. It even supplies a concrete batch use case (changing a channel value across many looks), leaving nothing to inference.

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

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

No annotations exist, so the description carries the full load, and it does the most important part well: a WARNING that the operation is destructive, irreversible, and permanently deletes undo/redo history. It omits permissions/auth requirements and scope side effects, keeping it just below a 5.

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

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

Front-loaded with purpose followed immediately by the destructive warning, which is the right ordering. The Parameters/Returns sections are somewhat redundant against the schema and no output schema exists, but the whole is short and readable.

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?

Complete for a two-parameter destructive tool: it conveys the destructive nature, the required confirmation flag, and the return fields in the absence of an output schema. Missing only auth/permission expectations, which would round it out.

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 both parameters are already documented in the schema, including confirmClear's 'Must be true' semantics. The description's parameter section largely restates the schema rather than adding format or constraint detail, 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?

The description states a specific verb+resource: 'Clear all operation history for a project.' This clearly distinguishes it from retrieval siblings like get_operation_history and manipulation siblings like undo/redo. It stops short of naming a sibling explicitly, so it lands at a strong 4.

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

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

Usage is implied by 'all operation history for a project,' but the description never says when to prefer this over undo/redo, get_operation_history, or jump_to_operation. With no exclusions or alternatives named, this is adequate-but-incomplete guidance.

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

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

No annotations, so the description carries full burden. It does disclose real behavioral traits — atomicity and undo/redo support — which is valuable. But it omits failure modes (what if a fixture is absent from a target look), whether existing target values are overwritten, and permission requirements, all significant for an unannotated mutation tool.

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

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

Three short sentences, front-loaded with the core action, followed by behavior and use case in descending priority. The trailing "efficiently" is mild filler, but there is no real padding.

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

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

For a 3-parameter mutation tool with no annotations and no output schema, the description covers purpose, atomicity, and undo/redo but leaves failure semantics and overwrite behavior unstated. Adequate but with clear gaps an agent would want filled.

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 three parameters are documented in the schema itself, including the constraint that fixtures must exist in the source look. The description adds no syntax, ordering, or ID-format detail beyond that, 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 and resource with clear scope: copy fixture channel values from one source look to many target looks. This distinguishes it implicitly from add_fixtures_to_look (structure vs values) and bulk_update_looks, though it never names a sibling to make the distinction explicit.

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

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

"Useful for propagating lighting changes across multiple looks efficiently" implies the use case but gives no explicit when-to-use conditions or contrast with add_fixtures_to_look / bulk_update_looks. An agent must infer the routing rather than being told.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing: it does not say whether existing looks are modified, whether the sequence is persisted with generated IDs, what ordering/side effects transitionPreferences produces, or what permissions are required. For a create/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?

A single tight sentence with the action and source front-loaded and no filler. It is efficient, though it is arguably too terse for a five-parameter mutation 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?

Five parameters (four required), a nested transitionPreferences object, no output schema, and no annotations leave a lot unexplained. The description omits return value, the meaning of the nested transition options, and whether looks are consumed or copied.

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 80%, so the schema already documents the individual parameters; baseline is 3. The description's 'from existing looks' loosely maps to lookIds but adds nothing about scriptContext or the nested transitionPreferences object.

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

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

States a clear verb+resource ('Create a sequence of lighting cues') and names the source material ('from existing looks'), which distinguishes it from nearby tools like bulk_create_cues. It stops short of explicitly naming which sibling to prefer when the agent just wants raw cues.

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

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

No when-to-use or when-not-to-use guidance. With siblings such as generate_act_cues, bulk_create_cues, and add_cue_to_list available, the description never says which situation calls for a sequence built from looks versus these 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 provided, the description carries the full burden of behavioral disclosure. It states it's a creation tool, implying mutation, but lacks details on permissions, side effects, error handling, or response format. This is a significant gap for a tool with 10 parameters and no output schema.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy 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?

Given the complexity (10 parameters, no annotations, no output schema), the description is inadequate. It doesn't explain what a 'fixture instance' entails in this domain, how creation interacts with other tools, or what the tool returns. For a mutation tool with rich parameters, more context is needed.

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

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

The schema description coverage is 100%, meaning all parameters are documented in the input schema itself. The description adds minimal value beyond the schema by mentioning 'manufacturer/model details', but it doesn't elaborate on parameter interactions or usage nuances. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Create a new fixture instance') and specifies the resource ('in a project with manufacturer/model details'), making the purpose understandable. It doesn't explicitly differentiate from sibling tools like 'update_fixture_instance' or 'suggest_channel_assignment', which prevents a perfect score.

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 like 'update_fixture_instance' or 'suggest_channel_assignment', nor does it mention prerequisites or context for usage. It's a basic statement of function without operational 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, the description carries the full behavioral burden for a mutation tool. It implies creation but says nothing about permissions, side effects, duplicate-name handling, or what happens to the 'custom layout' it references, leaving 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 compact sentence with the verb and scope front-loaded and no filler. It is efficient, though its brevity is what leaves the other gaps unfilled.

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

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

For a 7-parameter creation tool with no annotations and no output schema, the description is minimally adequate: the schema covers parameters, but there is no note on return values (e.g. a new board ID) or how it relates to near-identical siblings like create_look_board_with_buttons.

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 seven parameters (gridSize, canvasWidth/Height, defaults, etc.) are fully documented in the schema. The phrase 'custom layout' loosely gestures at the canvas/grid parameters but adds no format or constraint detail beyond the schema, 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?

The description gives a specific verb and resource ('Create a new look board') plus a purpose ('organizing looks with custom layout'), so the agent knows exactly what is being created. It does not, however, distinguish this from the very similar sibling create_look_board_with_buttons or bulk_create_look_boards.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternative (create_look_board_with_buttons). The agent is left to infer that this is the plain single-board creation path.

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 for a mutation tool. 'In a single operation' vaguely hints at atomicity but never states whether the board and buttons are created transactionally, what happens if one button is invalid, or what permissions are required. That is a significant gap for a create 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?

It is short, but the second sentence ('Allows defining an entire look board layout in one command') is a near-verbatim restatement of the first and does not earn its place. Front-loading is fine; content density is low.

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 create tool with no annotations and no output schema, the description covers the 'what' but omits the behavioral details an agent needs: atomicity, failure behavior, and how it relates to the non-combined sibling tools. The rich schema compensates for parameter documentation but not for 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% and all 8 parameters (including nested button fields and defaults) are documented in the schema, so the baseline is 3. The description adds no additional meaning about button structure, grid/canvas defaults, or fade time 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?

States a specific verb+resource: create a look board together with its buttons. However, it does not distinguish itself from close siblings like create_look_board, bulk_create_look_boards, or bulk_create_look_board_buttons, leaving the agent to infer that this is the combined single-shot variant. The second sentence largely restates the first.

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

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

No when-to-use guidance is given. Given siblings such as create_look_board plus bulk_create_look_board_buttons, the description should say when the combined operation is preferable (e.g. atomic creation vs. two calls), but it offers no condition or exclusion.

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 says nothing about permissions required, name uniqueness, what happens on duplicate names, what the call returns (e.g. new project ID), or default behavior beyond what the schema already states for groupId.

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 phrase with zero filler, which is efficient. It is arguably too terse for a mutation tool, but that under-specification is penalized in other dimensions rather than here.

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

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

For a creation/mutation tool with no annotations and no output schema, the description leaves key questions unanswered: what is returned, whether the name must be unique, and how it relates to bulk_create_projects. The schema covers inputs but nothing covers behavior.

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

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

Schema description coverage is 100%, so the schema already documents name, groupId, and description, including the groupId default. The description adds no parameter meaning beyond what the structured data provides, which is the baseline 3 case.

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 ('Create a new lighting project'), which is unambiguous about the domain. It does not, however, distinguish itself from the sibling bulk_create_projects or explain why a single-create exists alongside a bulk variant.

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

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

There is no when-to-use guidance, no mention of prerequisites (e.g. a group must exist), and no routing to the obvious alternative bulk_create_projects. The agent must infer everything from the sibling list.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose the important cascading effect (deletes the list AND all its cues), which is valuable, but omits irreversibility, undo support, and required permissions for a destructive operation.

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

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

A single front-loaded sentence with zero filler that leads with the verb and the cascading scope. Nothing wasteful, nothing missing from the core statement.

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 destructive mutation with no annotations and no output schema, the description covers the core action and its cascade but leaves out usage context, reversibility, and sibling routing. Adequate but with clear gaps.

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

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

Schema coverage is 100%, so both parameters (cueListId, confirmDelete) are fully documented in the schema, including the safety-confirmation semantics. The description adds no meaning beyond that, 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 (delete) and resource (cue list) plus the scope of the operation (and all its cues). It is clear what the tool does, though it does not explicitly distinguish itself from the singular/plural siblings like bulk_delete_cue_lists or remove_cue_from_list.

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

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

The description contains no when-to-use guidance, no prerequisites, and no mention of when to prefer this over bulk_delete_cue_lists or remove_cue_from_list. An agent must infer the single-list scope from the resource name alone.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a meaningful cascading side effect ('will remove it from all looks'), which is useful. However, it does not state that the deletion is permanent/irreversible, and the safety confirmDelete flag is only described in the schema, not the description.

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

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

A single efficient sentence with the action front-loaded and the cascading side effect appended in a concise parenthetical. Nothing is wasted, though it is not maximally informative.

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

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

For a two-parameter destructive tool with no annotations and no output schema, the description covers purpose and fan-out impact but leaves irreversibility, permissions, and error behavior unstated. Adequate but with clear gaps given the absence of safety 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 coverage is 100% and both parameters are fully documented there, so the schema does the heavy lifting. The description adds no syntax or format detail beyond the schema, making the baseline 3 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 verb and resource ('Delete a fixture instance') and scopes it to 'a project', which helps separate it from remove_fixtures_from_look (removes from one look, not deletes). It doesn't explicitly name how it differs from update_fixture_instance, but the core action is unambiguous.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternative sibling is named. An agent must infer that this is the single-instance counterpart to bulk_delete_fixtures and distinct from remove_fixtures_from_look.

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

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

With no annotations, the description carries the full burden, and it does disclose the important behavioral fact that child buttons are destroyed along with the board. However, it omits irreversibility, permission requirements, and whether the operation can be recovered via the sibling undo tool, which matters for a destructive mutation.

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 ten-word sentence that front-loads the action and ends with the highest-value detail (child deletion). No filler whatsoever.

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 but thin for a destructive, no-annotation mutation tool: it covers the cascade effect but says nothing about reversibility, undo availability, or the bulk alternative in a sibling set that includes bulk_delete_look_boards, undo, and remove_look_from_board. Nothing an agent needs to call it is missing, but routing context is not.

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

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

Schema description coverage is 100%, so both lookBoardId and the confirmDelete safety flag are already documented in the schema. The description adds nothing about parameter format or the confirmation requirement, 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?

States a specific verb (Delete) and resource (look board) plus the cascade scope: 'and all its buttons'. This implicitly separates it from remove_look_from_board, which removes a look from a board rather than deleting the board itself, though it never names a sibling explicitly.

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

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

There is no when-to-use guidance: nothing explains when to delete a single board versus using bulk_delete_look_boards, nor any preconditions beyond what the schema enforces. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool deletes a project and all its data, implying a destructive, irreversible action, but lacks details on permissions, side effects, or error handling. For a high-stakes deletion tool, this is insufficient.

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

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

The description is a single, direct sentence that efficiently conveys the core action without unnecessary words. It is front-loaded and wastes no space, making it highly concise and well-structured.

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

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

Given the tool's destructive nature, lack of annotations, and no output schema, the description is incomplete. It doesn't cover critical aspects like what 'all its data' entails, potential dependencies, or response format. For a deletion operation, more context is needed to ensure safe usage.

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

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

The input schema has 100% description coverage, clearly documenting both parameters (projectId and confirmDelete). The description adds no additional meaning beyond what's in the schema, such as explaining why confirmation is required. With high schema coverage, 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') and resource ('a project and all its data'), making the purpose immediately understandable. However, it doesn't differentiate from potential alternatives like 'remove_cue_from_list' or other deletion-like operations among siblings, which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing to confirm deletion, or compare it to other tools like 'remove_cue_from_list' for partial deletions. This lack of context leaves usage unclear.

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

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

With no annotations, the description carries the full burden. It does disclose the important behavioral trait that the operation is idempotent ('adding only if missing'), which is real value. However, it leaves a critical ambiguity: what happens when a fixture already exists with different values — update, ignore, or error? It also says nothing about live DMX output impact, permissions, or 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?

A single sentence with no filler; the behavioral qualifier ('adding only if missing') is placed where it matters, right after the core action. 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 mutation tool with no annotations and no output schema, the description covers the essential idempotency semantics but omits the effect on existing fixtures whose values differ, whether the change touches live output, and any confirmation of what is returned. Adequate but with a clear gap at the exact decision point an agent would hit.

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 each parameter (lookId, fixtureValues, channels, offset, value, lookOrder) is documented in the schema itself, so the baseline is 3. The description adds only 'with given values', which does not extend the schema's meaning.

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

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

The description names a specific verb+resource ('ensure specific fixtures exist in a look') plus a scope qualifier ('adding only if missing'), which implicitly separates it from add_fixtures_to_look. It never names a sibling explicitly, so the differentiation is inferential rather than stated.

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

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

The phrase 'adding only if missing' implies the idempotent use case (call when you want a guaranteed end state without duplicates, vs add_fixtures_to_look for unconditional insertion), but no alternative tool or triggering condition is stated. Usage must be inferred 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 carries the full burden and does so richly: it discloses truncation at a default 50000 characters with a truncated flag, that cuts may split rows, the file-write path resolution order (outputDirectory, then LACYLIGHTS_EXPORT_DIR, then temp), and that existing files are never overwritten but get a numeric suffix.

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

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

Front-loaded with the core action and split into scannable bullets, with the format distinction up top. It is somewhat long, but nearly every clause (truncation edge cases, path resolution, overwrite policy) carries decision-relevant information.

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

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

With no output schema and no annotations, the description fully compensates by describing return shapes for both formats (inline CSV text vs. a path/row-count/size for xlsx). An agent has everything needed to call it correctly.

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

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

Schema coverage is already 100%, but the description adds real meaning: it explains the csv/xlsx behavioral difference per format, that maxCharacters is CSV-only and ignored for xlsx, and that setting outputDirectory for CSV also saves the full untruncated file.

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 ('Export one data table ... as CSV or Excel') and enumerates the exportable tables. It is clearly distinguishable from sibling exporters export_data_workbook and export_eos_ascii by scoping to a single table.

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?

Routes the agent to list_data_export_tables to discover available tables and which need scopeId, and explains the csv-vs-xlsx choice. It stops short of explicitly contrasting with export_data_workbook, so the alternative-selection guidance is implied 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 and does well: it discloses the side effect (writes the file to disk), the return payload (path, total row count, size), and hard exclusions (FIXTURE_LIBRARY and the scoped tables). It omits permission/auth requirements, but the core behavioral profile is covered.

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

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

Three tight sentences, front-loaded with the action and output format, then the optional-parameter behavior, then the hard constraints. No filler or repetition.

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

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

No output schema exists, so the description correctly explains the return values (file path, row count, size), and with no annotations it covers the write side effect and table restrictions. A note on permissions or destination overwrite behavior would close the remaining 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%, so baseline is 3, and the description adds value beyond the schema: the explicit list of tables that cannot be included (FIXTURE_LIBRARY, LOOK_DETAILS, CUE_LIST_DETAILS, LOOK_BOARD_ENTRIES) is not in the schema, and it reinforces the omit-for-default and empty-list behavior.

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

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

States a specific verb+resource ('Export ... project tables as one multi-sheet Excel (XLSX) workbook') and clarifies the one-sheet-per-table output shape. It implicitly distinguishes itself from the single-table sibling export_data_table, but never names it, so an agent must infer the choice.

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

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

It gives useful conditions for the 'tables' argument (omit for the default set, FIXTURE_LIBRARY and scoped tables are not allowed), but never states when to prefer this multi-sheet tool over the sibling export_data_table or list_data_export_tables. Usage is implied rather than spelled out.

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

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

With no annotations, the description carries the full burden and does so well: it discloses the return shape (file content string, filename suffix, warnings), the round-trip preservation mechanism via $$ LACYLIGHTS comment lines, that EOS ignores those comments, and deterministic byte-identical output. It stops short of stating side effects or required permissions explicitly, so a 4 rather than 5.

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

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

Four tight sentences, front-loaded with the core action, then return shape, then preservation behavior, then determinism. No filler and every sentence adds distinct 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 single-parameter export tool with no output schema, the description covers what is produced (content string, filename suffix, warnings) and the non-obvious comment-preservation behavior, so nothing an agent needs to call and interpret it is missing.

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

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

Only one parameter and schema description coverage is 100%, so the schema already fully documents projectId. The description adds no syntax or format detail beyond it, making the baseline 3 the correct score.

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 (LacyLights project) and target format (ETC Eos ASCII .asc showfile), which cleanly separates it from siblings like export_data_table, export_data_workbook, and the inverse import_eos_ascii. An agent can identify the tool's output artifact without opening 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?

Usage is implied by the naming and the .asc format, but there is no explicit when-to-use guidance, no mention of when this is preferable to the data-table/workbook exporters, and no stated prerequisites. Adequate but leaves the agent to infer routing among the export family.

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 convey that the effect is global ('all lights'), but it says nothing about reversibility (undo), interaction with running cue lists or playback, or what happens to the current active look.

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

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

A single short sentence with the core action front-loaded and zero filler. It is very brief, but appropriately so for a simple one-argument 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 tool is simple (one optional param, no output schema), so the bar is low, but the description omits any behavioral detail about undo/restoration or how it interacts with active cues and looks. Adequate but leaves real gaps for a state-changing global 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 the fadeOutTime parameter (default 3s) is fully documented in the schema. The description adds only that a fade occurs, which the schema parameter name already implies. 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?

The description gives a specific verb and resource: 'Fade all lights to black', which an agent can distinguish from sibling tools like activate_look or next_cue. It does not explicitly name a sibling it contrasts with, but the action is unambiguous.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as activate_look or stop_cue_list. The agent must infer from the name alone that this is a global blackout operation.

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. 'Suggestions' hints at a non-mutating operation, but it never confirms whether cues are persisted, whether the caller must then call bulk_create_cues, or what permissions are needed. For a tool whose siblings include bulk_create_cues and create_cue_sequence, this ambiguity is material.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though arguably too terse given the absence of annotations and output 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?

A five-parameter tool with no annotations and no output schema needs more than one sentence. The description omits whether output is persisted, how the optional cueListName and existingLooks parameters alter behavior, and how the result relates to bulk_create_cues.

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 five parameters, including the optional cueListName and existingLooks. The description adds no format, constraint, or relationship detail beyond restating that the act's script text drives generation.

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

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

States a specific verb (generate) and resource (cue suggestions) with a clear scope (an entire act) and input basis (script analysis). It is distinguishable from analyze_script and bulk_create_cues because it produces 'suggestions' rather than analysis or committed cues, though it never names those siblings explicitly.

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

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

There is no statement of when to use this versus analyze_script, analyze_cue_structure, or bulk_create_cues, and no prerequisites or exclusions. The agent must infer the workflow position from the name alone.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it discloses almost nothing: it doesn't say whether the look is persisted, whether it is AI-generated or deterministic, whether it modifies existing fixtures, whether the project must exist first, or what activating does. The generative framing is the only behavioral hint.

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

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

A single front-loaded sentence with zero filler; the verb and resource lead. It is efficient, though arguably undersized for a seven-parameter tool with nested objects.

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

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

For a complex mutation tool with nested objects, seven parameters, no annotations, and no output schema, one sentence is not enough. Missing are persistence/return behavior, prerequisites, and how fixtureFilter and activate interact with the generated 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 coverage is 71% and the schema itself documents the notable parameters (lookType, fixtureFilter, activate, nested designPreferences fields). The description gestures at scriptContext and designPreferences but adds no format, default, or interaction semantics 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?

States a specific verb (generate) and resource (lighting look) plus the two conceptual inputs it draws from (script context, design preferences). However, it does nothing to separate itself from siblings like bulk_create_looks, optimize_look, or generate_act_cues, so an agent cannot tell which generation path applies without opening 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?

No when-to-use, when-not-to-use, or alternative routing is given. With ~30 look-related siblings in scope, the absence of any guidance on when to generate versus bulk-create, optimize, or manually build a look is a real gap.

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

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

With no annotations, the description carries the behavioral burden and does disclose the exact return fields, the running server context, and implies a read-only operation via 'Get.' It stops short of explicitly confirming no side effects or any authentication requirements, but for a zero-parameter read tool the disclosure is strong.

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 front-loaded with the purpose and uses clear headers for usage cases and return values. It is slightly repetitive in first naming the returned fields and then listing them again, but the structure is clean and easy to scan.

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 output schema and no annotations, the description fully explains what the tool returns (version, gitCommit, buildTime) and why an agent would call it. For this simple no-parameter read tool, no critical context is missing.

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

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

The tool takes zero parameters, so the baseline for parameter semantics is 4. The description correctly adds no parameter details because none exist, and it does not introduce confusion about inputs.

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

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

States a specific verb (Get) and resource (build information) with scope (backend server). It clearly distinguishes this from all sibling tools, which handle projects, looks, cues, fixtures, and boards, not server build metadata.

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

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

Provides explicit use cases: verifying server version after updates, debugging version mismatches, and confirming deployment success. It does not include when-not-to-use guidance or alternatives, but none are needed because no sibling covers this purpose.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'Get' and 'analyze', implying a read-only operation, but fails to specify if it requires permissions, has rate limits, returns structured data, or handles errors. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy to understand at a glance.

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 lack of annotations and output schema, the description is incomplete. It does not explain what a 'DMX channel usage map' is, the format of the returned data, or any behavioral aspects like error handling. For a tool that likely returns complex lighting data, more context is needed to guide effective 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?

The schema description coverage is 100%, with clear descriptions for both parameters ('projectId' and 'universe'). The description adds no additional meaning beyond the schema, such as explaining what a 'DMX channel usage map' entails or how the analysis works. Baseline 3 is appropriate since the schema adequately documents the parameters.

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

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

The description clearly states the action ('Get') and resource ('DMX channel usage map for a project'), making the tool's purpose understandable. However, it does not explicitly differentiate from sibling tools like 'get_fixture_inventory' or 'get_project_details', which might also retrieve project-related data, leaving some ambiguity about its unique role.

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 'get_fixture_inventory' or 'get_project_details', which might overlap in project analysis. There are no explicit instructions on prerequisites, context, or exclusions, leaving usage decisions unclear.

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 return contents (metadata, look info, cue list info), which compensates for the missing output schema and implies a safe read. It does not cover error behavior when a cue is not found or any permission requirements, keeping it short of a 5.

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

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

Front-loaded with the core purpose, then organized into Returns, when-to-use, use cases, and a routing note. Every section earns its place, especially the return list given there is no output 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?

For a single-item read tool with no annotations and no output schema, the description covers what it returns, when to use it, and the sibling to use instead. Nothing an agent needs to invoke it correctly is missing.

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

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

Single parameter with 100% schema description coverage, so the schema already documents cueId. The description adds only that lookup is 'by ID', which is marginal beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (get) and resource (cue) scoped to a single item by ID, and explicitly distinguishes itself from the lookup sibling get_cue_list_details. An agent can tell what it does and what it is not for without opening either 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?

Provides an explicit when-to-use statement ('when you need to inspect a single cue in detail'), concrete use-case examples, and names the alternative (get_cue_list_details) with the condition that selects it (lookup by number/name). Routing is unambiguous.

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

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

With no annotations, the description carries the full burden and does disclose real behavioral traits: includeLookDetails can produce very large payloads, pagination prevents context overflow, and defaults for page/perPage. It does not mention any auth/permission requirements or error behavior, which is a modest gap for a no-annotation 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?

Front-loaded with the core purpose, then organized into Parameters, Returns, and Example workflow sections that are easy to scan. The parameter list largely duplicates the schema descriptions, which is minor waste given the useful additions around payload size and pagination.

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 output schema, the description compensates by enumerating the return shape (metadata, cues array, pagination info, statistics, lookup tables). Combined with defaults, sorting, and filtering hints, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine meaning beyond the schema: the warning that includeLookDetails may be 'very large' and the default/max guidance on pagination that frames when to use it. The filterBy examples are listed only sketchily ('etc.'), so it does not fully enrich every parameter.

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

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

States a specific verb and resource ('Get cue list with its cues, optionally paginated') and distinguishes itself from the sibling list_cue_lists by casting that tool as the discovery step in the worked example. An agent can tell immediately that this retrieves the contents of one known cue list rather than enumerating lists.

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 example workflow explicitly names list_cue_lists as the alternative for finding lists, then routes to this tool with page=1 and subsequent pages when hasMore is true. It also gives a conditional rule for includeLookDetails ('only if you need full look data') and a concrete threshold for pagination (50+ cues).

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

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

No annotations are supplied, so the description carries the full behavioral burden. 'Get information' implies a read, but the description doesn't say what happens when nothing is playing, whether an error is returned, what the status payload contains, or whether any state changes. For a zero-annotation status tool this is a real gap.

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

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

A single efficient sentence with the core action front-loaded ('Get information about the currently playing cue list'). No filler or redundancy, though it is arguably too terse for the behavioral detail it omits.

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

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

With no output schema, the description is the only place an agent can learn what 'status' returns. It gestures at 'currently playing cue list and navigation options' but never enumerates the fields or states the no-active-list case, leaving the agent under-informed for a state-inspection tool.

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

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

The tool takes zero parameters and the schema is trivially complete, so there is nothing for the description to disambiguate. Baseline of 4 applies for a parameterless tool.

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

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

States a specific verb and resource: getting information about the currently playing cue list, plus navigation options. This is distinguishable from list_cue_lists (enumeration) and get_cue_list_details (details of a specific list), though the description never explicitly draws that distinction. The 'navigation options' phrase is somewhat vague but still signals a status/state read.

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 call this versus get_cue_list_details, list_cue_lists, or the next_cue/previous_cue navigation siblings. There is no mention of prerequisites (e.g., must a cue list be playing) or exclusions. Usage is only inferable from the name and the word 'currently playing'.

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

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

No annotations exist, so the description carries the full behavioral burden, but the tool is a zero-argument read, so little needs disclosing. 'If any' is a genuinely useful signal that the result may be empty or null. It still says nothing about auth requirements or what an 'active look' object contains.

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

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

One short sentence with zero filler, and the qualifier that matters most ('currently active', 'if any') is front-loaded. Nothing could be removed without losing 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 zero-param, no-output-schema tool the definition is minimally sufficient, but it leaves the return shape unexplained and never defines what makes a look 'active' versus merely existing or being on a look board. With almost no structured context to lean on, a sentence or two more would materially 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 takes no parameters, so the baseline for parameter semantics is 4. The description correctly implies parameterless operation and adds no misleading argument hints.

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 ('get the currently active look'), which is more precise than a bare 'get look' because it names the state being queried. However, it never distinguishes itself from close siblings like get_look, list_looks, or activate_look, so an agent must infer the difference.

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 phrasing 'if any' implies this is a non-destructive status query that may return nothing, which hints at when it applies. There is no explicit when-to-use statement, no exclusions, and no pointer to alternatives such as get_look or list_looks for the non-active case.

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