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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds the per-layer scoping and the 0.0-1.0 range, but says nothing about whether the effect must be switched on, how layers interact, or what 'per layer' means operationally.

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 range in the first sentence, followed by a compact Args/Returns block. Slight waste in the boilerplate 'Returns: JSON confirmation', which is redundant given an output schema exists.

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

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

An output schema exists, so the return format needn't be explained, and annotations cover the mutation/idempotency profile. For a single-parameter setter, the description supplies the operation, target, and value range, which is sufficient 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?

Context reports 0% schema description coverage at the top level, but the nested ForceInput schema does document 'level' (macro/meso/micro) and 'value' (0.0-1.0). The description merely restates the parameter names ('params: level and value') and repeats the range, adding no syntax or constraint detail beyond the schema.

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

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

States a specific verb and resource: 'Set Black Hole gravitational force per layer', with the value range included. An agent can distinguish it from polynodes_blackhole_switch and polynodes_whitehole_force by the force-vs-toggle and black-vs-white distinction, though the description 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?

No when-to-use, prerequisites, or alternatives are given. An agent must infer that this sets a continuous force value whereas polynodes_blackhole_switch toggles the effect on/off, and nothing indicates whether the black hole must first be enabled.

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

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

Annotations already declare the full safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the agent knows this is a safe, repeatable mutation. The description adds only 'Returns: JSON confirmation', which is redundant given an output schema exists, and says nothing about latency, affected state, or side effects beyond the annotations.

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

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

The lead sentence is well front-loaded with the action and target, but the boilerplate 'Args:' and 'Returns:' blocks add little and the Args line is effectively word-for-word filler ('params: state').

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 switch with an output schema and rich annotations, the description is minimally sufficient: the agent can identify the tool and know its return is a JSON confirmation. It lacks any note about what state the Black Hole DSP is left in or how it interacts with the force/whitehole siblings.

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

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

Schema description coverage is reported at 0%, so the description must compensate, but 'params: state' merely restates the parameter name and conveys nothing about the accepted values (0.0 off / 1.0 on). The only real semantics live in the nested schema definition, not the description.

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

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

States a specific verb and resource ('Turn the Black Hole DSP interactable on or off'), which is clear enough to distinguish from siblings like polynodes_whitehole_switch or polynodes_blackhole_force. It does not explicitly name those alternatives, but the resource naming makes the scope obvious.

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 the closely related whitehole_switch, blackhole_force, or generic switch tools, and no prerequisites or context are given. Usage must be inferred entirely from the tool name.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, destructiveHint=false, providing a strong safety and behavior profile. The description adds the radians unit and mentions 'JSON confirmation' as the return, but doesn't describe effects on visual state beyond rotation or any side effects. With annotations covering most behavioral aspects, a 3 is appropriate.

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

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

The description is brief and front-loads the key action. The 'Args:' and 'Returns:' sections are somewhat boilerplate but get to the point without 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?

With a rich set of annotations and an output schema present, the description need not explain return values in detail, but it should do more to clarify parameter semantics given the 0% schema coverage. It's adequate but incomplete for a mutation tool with an undocumented parameter.

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

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

Schema description coverage is 0%, so the description must compensate. It only states 'value in radians' and 'params: value', which is minimal and doesn't clarify the parameter's range or direction (clockwise vs counterclockwise). This is a significant gap for an undocumented numeric 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+resource ('Rotate the 3D camera') which is clear, but provides no differentiation from the sibling polynodes_camera_zoom or other camera tools. The purpose is understandable but siblings like camera_zoom aren't distinguished.

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 tool vs alternatives. Mentioning that the value is in radians is the only contextual hint. There's no mention of when to rotate the camera or relation to camera_zoom.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The only addition is 'Returns: JSON confirmation', which duplicates what the existing output schema already communicates; nothing about state change, persistence, or scope is disclosed.

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

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

The core sentence is short and front-loaded, but the 'Args: params: value' and 'Returns: JSON confirmation' lines are boilerplate padding that restate the schema and output schema rather than adding information.

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

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

For a single-parameter camera tool with an output schema and annotations covering safety, the description is minimally sufficient to call it. It still leaves open which camera/scene is targeted and how large a zoom step is meaningful, so it is 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 reported as 0%, so the description is expected to compensate. It restates the sign convention (positive=in, negative=out) but gives no units, valid range, or magnitude guidance, and the 'Args: params: value' line is a tautology that clarifies nothing.

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

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

The first sentence gives a specific verb and resource (zoom the 3D camera) plus the sign convention, which is enough to distinguish it from most siblings. It does not, however, differentiate itself from the closely related polynodes_camera_rotate that appears in the sibling list.

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

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

There is no statement of when to use this versus alternatives, no prerequisites (e.g. which scene/camera is affected), and no mention of polynodes_camera_rotate even though camera navigation is the obvious adjacent capability.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety and repeatability profile is covered. The description adds only 'Returns: JSON confirmation', which is thin and partially redundant given an output schema exists; it says nothing about whether toggling affects existing comb settings or what errors occur if the level is invalid.

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 operative instruction is front-loaded in a single sentence, and the Args/Returns scaffolding is compact. The Returns line contributes little value, but nothing is bloated or buried.

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

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

For a simple idempotent boolean toggle with an output schema available, the core action is conveyed. However, it omits the invalid-level/error behavior and the level-to-layer terminology mapping, leaving the agent to guess at edge conditions.

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 'params: level and state' line merely restates the parameter names without adding meaning beyond the schema. With schema description coverage reported at 0%, the description is expected to compensate for the undocumented parameters, and it does not explain valid levels or the boolean-like state semantics.

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

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

The first line states a concrete verb and resource ('Turn comb filter on/off'), which is clearly distinct from sibling setters like polynodes_set_comb_delay and polynodes_set_comb_mod_range. The only wrinkle is the term 'layer' in the description versus 'level' (macro/meso/micro) in the schema, an inconsistency the description never reconciles.

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 polynodes_filter_switch, polynodes_resonator_switch, or the other *_switch siblings, nor any prerequisites (e.g., needing comb delay set first). The usage is only implied by the tool name.

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

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

Annotations already declare the safety profile (idempotent, non-destructive, not read-only), so the description's 'Returns: JSON confirmation' adds almost nothing. It says nothing about whether the bitcrusher must be enabled, whether the change is applied live, or how it interacts with crush_range.

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

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

Very short, but the 'Args: params: value.' and 'Returns: JSON confirmation.' blocks are pure boilerplate that restate structured fields without adding meaning. The single substantive sentence is front-loaded, which is good.

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

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

An output schema exists so return values need no prose, yet the description still spends a line on 'JSON confirmation'. For a mutation tool in a large audio-effects family, nothing is said about required state, interaction with the crush switch, or effect of the change.

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

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

Schema description coverage is 0%, so the description carries the burden, yet it only offers 'params: value' — a tautological restatement of the schema key. The one useful fact, the 0.0-1.0 range, is already encoded as minimum/maximum in the schema.

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

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

States a specific verb and resource: 'Set bitcrusher bit depth level', with a value range. This distinguishes it from the sibling polynodes_crush_switch (on/off) and polynodes_crush_range, 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?

No indication of when to use this tool versus polynodes_crush_switch or polynodes_crush_range, and no preconditions (e.g. whether the bitcrusher must be switched on first). The agent must infer usage entirely from the name.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the safety bar is lower. The description adds only a vague 'JSON confirmation' return note and no rate limits or auth context, so it adds modest value over the annotations.

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

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

The core purpose is front-loaded in one short sentence, which is good, but the boilerplate 'Args: params: value.' line and 'Returns: JSON confirmation.' add words without 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 setter with annotations and an output schema, most essentials are covered by structured data. Still missing is what the range semantically controls (e.g., sampling-frequency multiplier) and how it relates to polynodes_crush_bit_level.

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

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

Schema description coverage is 0% and the description's parameter section ('Args: params: value') is a tautology that restates the property name without meaning. The 0.0-5.0 range it cites is already enforced by the schema's minimum/maximum and the nested value description, so it does not compensate for the coverage gap.

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

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

The description names a specific verb ('Set') and resource ('bitcrusher sampling frequency range') with its value domain, so the tool's function is unambiguous. It does not, however, distinguish itself from adjacent siblings such as polynodes_crush_bit_level or polynodes_crush_switch.

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 prerequisites, and no reference to the sibling crush tools an agent could confuse this with. Usage is only inferable from the name itself.

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

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

Annotations already declare idempotentHint=true and destructiveHint=false, so the agent knows repeated calls are safe and nothing is destroyed. The description adds the on/off semantic but doesn't note it as a confirmation-only operation beyond 'JSON confirmation.' With annotations carrying the safety profile, moderate credit is appropriate.

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

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

Very short but structured as Args/Returns, front-loading the purpose. The 'Returns: JSON confirmation' is low-value given an output schema exists. Minimal but not wasteful; however the arg description is nearly empty.

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?

Output schema exists, so return-value explanation isn't needed. For a single-parameter toggle with good annotations and documented value bounds, the description is adequate but thin — it doesn't state scope (per-node vs global) or how it interacts with the other crush 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 listed as 0% at the top level, but the nested SwitchInput definition does document 'state' with '0.0 = off, 1.0 = on' and min/max bounds. The description's 'params: state' adds nothing beyond that. Baseline 3 because the nested schema actually documents the parameter well.

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

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

Clear verb+resource: toggling Bitcrusher/Decimater on/off. Sibling tools like polynodes_crush_bit_level and polynodes_crush_range are related but not the switch, so the purpose is distinguishable. The typo 'Decimater' is a minor blemish but doesn't obscure the meaning.

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

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

The description implies usage via the on/off framing, but there is no explicit statement of when to use this versus the related crush parameter tools (bit level, range). For a switch tool among many siblings, more routing guidance would help.

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

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

Annotations already declare idempotent, non-destructive, non-read-only, and open-world behavior. The description adds only the range and 'JSON confirmation,' both of which are already available via the schema and output schema, so it provides little extra behavioral context.

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

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

The description is short and front-loaded, but the Args and Returns boilerplate adds little and the whole description is under-specified rather than richly concise.

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

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

For a simple parameter setter with annotations and an output schema, the description gives enough to invoke the tool minimally. However, it does not explain what the cuboid FX return level affects or clarify the layer parameter beyond what the schema already states.

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 reported as 0% at the top level, and the description merely says params contains level and value. It does not explain the macro/meso/micro layer values or the meaning of value beyond the range already present in the schema.

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

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

The description states a specific verb and resource: set cuboid FX return level, and clarifies the scope as per layer with the valid range. It is clear enough to distinguish from most siblings, though it does not explicitly contrast with related cuboid or FX tools.

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

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

It only says what the tool does, not when to use it versus alternatives or when not to use it. No prerequisites, context, or sibling routing are provided.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is covered structurally. The description adds almost nothing beyond that: 'Returns: JSON confirmation' is redundant because an output schema exists, and it says nothing about persistence, audio-routing side effects, or what an off state does to in-flight playback. With annotations doing the heavy lifting, this is thin.

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 operative sentence is front-loaded and the whole description is only a few lines. The Args/Returns blocks duplicate the schema and output schema respectively, which is mild padding but keeps it scannable.

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

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

For a two-parameter toggle with full schema coverage, an output schema, and complete annotations, the description covers everything an agent needs to invoke it. The only omission is any note on the cuboid's effect context, which is not strictly required to call the tool.

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

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

Schema description coverage is 100% and both parameters (cube, state) are fully documented in the schema, including the 0.0/1.0 mapping. The description merely repeats those definitions verbatim, adding no syntax, defaulting, or edge-case meaning. Baseline 3 applies when the schema does all the work.

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 pair ('Turn a cuboid (C1/C2/C3) on or off') and enumerates the valid targets, so it is immediately distinguishable from the many other *_switch siblings that act on different effects (granular, filter, comb, blackhole, etc.). No ambiguity about what is being toggled.

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 toggle semantics and the per-cuboid scoping, but there is no explicit when-to-use/when-not guidance and no mention of an alternative when a different cuboid index or effect is wanted. Adequate for a trivial toggle, but nothing is 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds only 'Returns: JSON confirmation,' which is redundant because an output schema exists, and contributes no additional behavioral context beyond the annotations.

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

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

The description is short, front-loaded, and free of unnecessary text. The Args and Returns lines are minimal boilerplate, though the Returns line is redundant given the 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 simple on/off switch with rich annotations and an output schema, the description covers the core action and param names well enough. Usage guidance is missing, but the structured fields fill most gaps.

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

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

Schema description coverage is 0% per context signals, so the description must compensate. It merely names 'level and state' without explaining their meanings or formats, adding no semantic value over 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 (turn on/off) and resource (bandpass filter) with scope (for a layer). This clearly distinguishes it from sibling tools that set filter frequency or modulation range.

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 only lists args and returns, leaving the agent to infer context 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, which correctly frames this as a safe, repeatable state setter. The description adds the binary state semantics and the fact that it returns a JSON confirmation, but does not say whether soloing one layer unsolos others or how it interacts with overall gain.

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 action statement followed by a compact Args block and a one-line Returns note. Every line earns its place with no filler, though the Args block largely duplicates the schema.

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

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

For a simple binary-state setter whose annotations cover the safety profile and whose output schema covers the return value, the description is nearly sufficient. The only unaddressed behavior is the side effect on other layers when soloing.

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?

Top-level schema coverage is 0% for the single 'params' object, but the nested properties are already fully documented in the schema ('macro', 'meso', or 'micro'; 0.0 = off, 1.0 = solo). The description restates level and state but adds no meaning beyond those nested descriptions, so it neither fully compensates nor adds value.

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 (solo) and resource (a specific layer, scoped as macro/meso/micro), which is enough to tell it apart from the many switch/set siblings. It is clear but does not explicitly contrast itself with close relatives like polynodes_set_gain.

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 argument semantics (1.0=solo, 0.0=unsolo), so an agent can infer that this sets a binary solo state per layer. However, there is no explicit when-to-use guidance, no statement of when to prefer this over polynodes_set_gain, and no exclusions.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds only 'Returns: JSON confirmation,' which is redundant given an output schema exists, and says nothing about this being a real-time audio parameter change with immediate audible effect.

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

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

The definition is short and front-loads the core action, which is good, but the 'Args: params: value.' and 'Returns: JSON confirmation.' lines are pure boilerplate that consume space without adding information.

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

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

For a live audio parameter setter among 40+ similar siblings, the description should at least say what the number measures and how it interacts with the granular switch. It omits everything beyond the range, and while an output schema exists, the one genuinely useful disclosure (real-time sound modification) is absent.

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

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

With schema description coverage reported at 0% and only one nested object parameter, the description carries the load but offers almost nothing: 'params: value.' is boilerplate that adds no meaning, and the 10-1000 range merely repeats the schema's own minimum/maximum. Units and the effect of the duration value on granular playback are never stated.

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 ('Set granular chunk duration') with the valid range (10-1000), so an agent can distinguish it from unrelated siblings like polynodes_set_gain. However, it does not differentiate itself from close siblings polynodes_granular_duration_mod_range or polynodes_granular_switch, leaving ambiguity about which granular parameter is being set.

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 when to prefer a sibling such as the mod-range variant. The only implied context is that this belongs to a granular synth section, which the agent must infer from the name alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only that it returns a 'JSON confirmation,' which is minimal; it says nothing about which device/node is affected, whether the change persists, or how it interacts with the base granular duration.

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

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

The description is short and front-loads the operation, but the 'Args: params: value.' and 'Returns: JSON confirmation.' boilerplate adds no information and reads as auto-generated filler.

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

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

An output schema exists, so return values needn't be explained. However, for a one-parameter mutation tool in a family of ~25 similarly named setters, the description omits any disambiguation against granular_duration or set_playback_rate_mod_range, leaving the agent with insufficient context to pick correctly.

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

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

Schema description coverage is reported at 0% for the top-level 'params' wrapper, and the description's 'params: value.' restates the parameter name without adding meaning. The 0.0-0.75 range is already enforced and documented in the nested schema, so the description compensates for nothing.

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 ('Set granular duration modulation range') and includes the valid range, which distinguishes it from siblings like polynodes_granular_duration and polynodes_set_playback_rate_mod_range. It stops short of explicitly contrasting with those siblings, so it is clear but not maximally 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 guidance on when to use this tool versus the granular duration control or the other mod-range setters. The agent must infer context from the name alone.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety/idempotency profile is covered. The description adds only 'Returns: JSON confirmation,' which is thin given an output schema exists, and restates the state mapping already in the schema.

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

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

Front-loaded and very short, with the core behavior stated first. The boilerplate 'Args:'/'Returns:' scaffolding is slightly wasteful but not distracting.

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 toggle with an output schema and annotations covering safety, the description supplies the essential mapping and a return indication. It could say more about the wrapper object, but nothing critical for calling 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?

The top-level 'params' wrapper has no schema description (coverage 0%), so the description usefully clarifies that params carries 'state' with 1.0=on and 0.0=off, compensating for the wrapper's opacity. However it adds no format or type detail beyond what the nested SwitchInput already documents.

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

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

Clearly states a specific verb+resource ('Turn the granulator on or off'), distinguishing it from the many sibling switch tools targeting other effects (filter_switch, comb_switch, etc.). It does not name an alternative or exclusion, but the resource name 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 guidance on when to use this versus other switch tools or when toggling is appropriate. The 'Args:' line just restates the schema rather than providing selection criteria.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety and idempotency profile is covered structurally. The description adds almost nothing beyond the value range (which the schema itself already states) and a generic 'JSON confirmation' note; it says nothing about units, clamping behavior at the 0/5000 bounds, or whether the isomorph module must be active.

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 purpose sentence is front-loaded and tight, but the 'Args: params: value' and 'Returns: JSON confirmation' boilerplate is pure filler given the schema and existing output schema. A single-parameter setter needs one sentence, not a stub docstring scaffold.

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

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

For a one-parameter numeric setter with annotations and an output schema, the description is only just sufficient: it states the action and the range. Missing are the unit of measurement, behavior at boundaries, and any dependency on the isomorph switch, which an agent would need to call this correctly in context.

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

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

Schema description coverage is 0% per the context signals, so the description carries the burden, yet 'Args: params: value' is a tautology that simply renames the parameter. The '(0-5000)' range is the only substantive detail and merely duplicates the schema's own min/max and nested description; no unit (Hz?) or effect on the signal is explained.

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

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

The first sentence names a specific verb and resource ('Set isomorphic bandpass center frequency') plus a range, which distinguishes it from the many sibling setters like polynodes_set_filter_freq or polynodes_isomorph_mod_depth. It stops short of explicitly contrasting with those siblings, so it is clear but not sibling-differentiating.

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

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

There is no statement of when to use this tool versus alternatives, nor any prerequisite such as needing polynodes_isomorph_switch enabled or a note about interaction with polynodes_isomorph_mod_depth. Usage is left entirely to inference from the name.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false and openWorldHint=true, so the safety profile is known. The description adds the valid value range (0.0-2.0) but nothing about auth, hardware state, or what the JSON confirmation contains beyond what annotations and the output schema provide.

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 scoping sentence with the range, followed by brief Args/Returns boilerplate. Efficient overall, with the Returns line being slightly redundant given an output schema exists.

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

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

An output schema and rich annotations already cover return shape and safety, and the description supplies the depth range. What is missing is the relationship to the isomorph modulation switch siblings, leaving a gap an agent must resolve itself.

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?

Top-level schema coverage is 0%, so the description must compensate; it names the nested fields ('params: param and value') and repeats the 0.0-2.0 range, but omits the enum values 'freq', 'amp', 'res' for the param field. The nested schema does carry those, so the description is only marginally additive.

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

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

States a specific verb+resource ('Set isomorphic modulation depth') and enumerates the three targets ('freq/amp/res'), so an agent can tell what the tool affects. It does not explicitly differentiate from nearby siblings like polynodes_isomorph_mod_switch or polynodes_isomorph_switch, which govern enable/disable versus depth.

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, no prerequisites, and no mention of alternatives such as the sibling switch tools. The agent must infer that this sets depth while isomorph_mod_switch toggles it.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false, and openWorldHint=true, so the mutation/safety profile is largely covered. The description adds the state-toggle semantics and the fact that a JSON confirmation is returned, but discloses nothing about persistence across sessions, whether turning off resets depth, or OSC-side effects.

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

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

Front-loads the action in one line and uses labeled Args/Returns sections, so it is easy to scan with no filler. The only minor cost is that the Args and Returns text duplicates information already in the schema 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?

For a two-parameter toggle with an output schema handling return values and annotations covering safety, the description is sufficient to invoke correctly. It falls short only on module-state prerequisites, which a slightly richer description could address.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema itself; the Args block merely restates param values and the 0.0/1.0 states. Baseline 3 is appropriate since the description adds no format or behavioral nuance beyond the structured fields.

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 ('Turn on/off') and a specific resource ('isomorphic modulation target') with the three accepted targets named. It is clear enough to separate from sibling toggles like polynodes_isomorph_switch or polynodes_granular_switch, but it does not explicitly distinguish 'mod' switch from the plain isomorph switch in the sibling 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?

No when-to-use, when-not-to-use, or alternative routing is given. The description never states the prerequisite (an isomorphic module already active) nor points to related siblings such as polynodes_isomorph_switch or polynodes_isomorph_mod_depth. Usage is only inferable from the name and args.

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

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

Annotations already declare the safety profile (idempotent, not read-only, not destructive), so the bar is lower, but the description adds nothing beyond 'JSON confirmation' - no state persistence, no side effects on the audio graph, no indication of what a toggle does to an in-progress effect.

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

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

It is short and front-loaded, which is good, but the 'Args:'/'Returns:' blocks are boilerplate that recite the schema and add no information - borderline waste rather than concise value.

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 an output schema present, the return value need not be explained, and the state semantics are covered in the nested schema. Still, for a modulation toggle no context is given about the effect being switched or how it interacts with siblings like isomorph_mod_depth.

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

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

Schema description coverage is 0% at the top level, so the description must compensate; instead it merely restates the schema ('params: state') without adding meaning. The actual 0.0=off/1.0=on semantics live in the nested $defs, not in the description, so no value is added here.

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

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

States a specific verb and resource ('Turn IsoMorph modulation on or off'), which is clear enough to act on. However, it does not differentiate itself from the near-identical sibling polynodes_isomorph_mod_switch, whose name an agent could easily confuse with this one.

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

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

There is no guidance on when to toggle this switch versus related siblings, no prerequisites (e.g., whether an IsoMorph effect must be selected first), and no mention of the alternative polynodes_isomorph_mod_switch. Usage must be entirely inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful context beyond annotations by stating the return shape and that addresses are grouped by category with parameter ranges.

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 plus a Returns block. The core purpose is front-loaded, and every line adds useful detail without redundancy.

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

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

For a no-parameter discovery tool with a rich output schema and read-only annotations, the description is complete enough. It states what is returned and how it is organized, while the output schema handles detailed response structure.

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 schema has no parameter semantics to document. Baseline for zero parameters is 4, and the description appropriately does not invent parameter information.

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, resource, and scope: list all available PolyNodes OSC addresses and their parameter ranges. This clearly distinguishes it from sibling setters and send_raw_osc, which act on specific parameters or send messages rather than enumerate the OSC address space.

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

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

Usage is implied: call this when you need an inventory of OSC addresses and their ranges. However, the description does not explicitly say when to use this versus send_raw_osc or the many parameter-setting siblings, nor does it mention that this is a discovery prerequisite before targeting addresses.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=true, and openWorldHint=true, so the safety profile is covered. The description adds little beyond restating that it triggers changes and returns JSON confirmation, which is redundant given the output schema exists. It does not disclose what the mode change affects or any side effects.

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

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

The description is very short and front-loads the purpose. The Args/Returns docstring style is structured, though the 'Returns: JSON confirmation' line is unnecessary because an output schema already exists.

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

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

Given the tool's simplicity, annotations, and output schema, the description is minimally adequate. However, it still leaves the agent without clear usage guidance and without an explanation of what 'random navigation mode changes' actually do, which limits confident 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 reported as 0%, so the description should carry more of the parameter burden. It only says 'params: state 1.0=on' and omits the off value, the nested object structure, and the meaning of the state parameter in context.

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: 'Trigger random navigation mode changes.' This is clear enough to distinguish it from most sibling parameter-setting tools, but it does not explain what 'random navigation mode' means or how it differs from related trigger tools like polynodes_rearrange_trigger.

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 guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The only usage-related detail is that 'params: state 1.0=on,' which is parameter information rather than contextual guidance.

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

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

Annotations already disclose readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that it sends an OSC message and returns a JSON confirmation, which is useful context beyond the annotations.

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

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

Short and front-loaded with the purpose; the Args and Returns sections are compact. Slight redundancy with the schema but nothing wasteful.

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 playback toggle with annotations covering idempotency and safety, the description is adequate. The output schema exists so return-value detail isn't strictly needed, though it mentions the confirmation anyway.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it does: it explains state=1.0 plays and state=0.0 stops, giving the only meaningful semantics for the single required parameter.

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

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

The description states a specific verb and resource: start or stop PolyNodes playback. It's clearly distinguishable from siblings like polynodes_set_gain or polynodes_set_bpm, though it doesn't explicitly name an alternative.

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

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

Usage is implied through the state values (1.0 to play, 0.0 to stop), which conveys how to invoke it, but there is no explicit guidance on when to choose this over related transport or playback tools.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false, covering the safety profile. The description adds the meaningful detail that gating is BPM-synced, which is not in the annotations, but says nothing about timing/latency or what 'JSON confirmation' actually contains beyond the output schema. Adds some value but not rich behavioral context.

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 purpose is front-loaded and the text is short, but the boilerplate 'Args:' and 'Returns:' blocks are template padding for a single trivially-named parameter and an already-published output schema. Efficient overall but not every line earns its place.

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

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

For a one-parameter idempotent switch with annotations and an output schema, the essentials are present, and the BPM-sync note helps. However, it omits any note on parameter meaning or interaction with playback timing, leaving minor gaps for a gating tool embedded in a larger synth.

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 reported at 0%, so the description is supposed to carry the load, yet 'params: state.' merely restates the parameter name without explaining the 0.0/1.0 semantics (the actual meaning lives only in the nested schema). It adds essentially no meaning beyond the structured field.

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 ('Turn Poly Gates on or off') and adds the scope qualifier 'BPM-synced layer gating', which lets an agent separate it from the many sibling *_switch tools that gate other modules (granular, filter, resonator, comb, etc.). It does not explicitly name those siblings, so it falls just short of a 5.

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

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

The named target ('Poly Gates') implies when this tool applies versus the other module switches, but there is no explicit when-to-use guidance, no conditional logic, and no named alternative. Usage is only inferable from the resource name.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description only adds the 1-10 range and 'JSON confirmation', both of which are already implied by the schema and output schema, so it contributes little new behavioral context.

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?

Very short and front-loaded with the core action; the Args/Returns docstring block is slightly boilerplate but costs little. No filler.

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

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

For a one-parameter tool with an output schema, not explaining return values is acceptable. However, the description omits what happens to the existing patch when a preset slot is loaded, which is the key behavioral fact an agent would need.

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 reported as 0% at the top level: the 'params' property has no description, though the nested PresetSlotInput.slot does carry 'Preset slot number (1 to 10)'. The description compensates by documenting 'params: slot number 1-10', clarifying the nested structure and valid range, but adds nothing beyond that.

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 ('Select a preset slot (1-10) on PolyNodes'), which is unambiguous. It does not explicitly distinguish itself from siblings like polynodes_play_stop or the various setter tools, but the resource is distinct enough in context.

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

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

There is no guidance on when to use this versus alternatives, what 'selecting a slot' does to the current patch state, or any prerequisites. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds only that a JSON confirmation is returned, but fails to disclose the key behavioral fact that this is a stateful toggle (calling with state=0 turns Re-Arr mode off) rather than a fire-and-forget trigger.

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

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

The definition is short and front-loads the purpose, which is good. But the boilerplate 'Args:/Returns:' block consumes most of the text while conveying almost nothing ('params: state', 'JSON confirmation'), so the brevity reflects under-specification rather than tight writing.

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

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

For a one-parameter mode switch sitting among dozens of near-identically named siblings, the definition omits what Re-Arr mode audibly does, when to enable it, and how the state toggle behaves. Annotations and the output schema cover safety and response shape, but the functional gap remains significant.

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

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

Schema description coverage is 0% at the top level, so the description must carry the meaning of 'params', and it only restates 'params: state' with no explanation of the 0.0/1.0 semantics or what happens on transition. It adds essentially nothing beyond the parameter name.

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

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

The description gives a verb (Trigger) and a resource (Re-Arr mode) and adds a parenthetical gloss ('rearranges input sample chunks'), so the general intent is inferable. However, 'Re-Arr mode' is unexplained jargon, and the tool is not distinguished from any of its ~40 siblings (e.g. polynodes_navigation_random_trigger), which also carry 'trigger'-style names.

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 invoke this versus the many sibling switch/trigger tools, and no prerequisites or exclusions are stated. The word 'Trigger' even suggests a one-shot action, while the schema shows an on/off mode switch, leaving the agent to infer usage entirely.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false, and openWorldHint=true, so the safety and idempotency profile is covered. The description adds only that the return value is a JSON confirmation, which is redundant given there is an output schema; it adds little beyond annotations.

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

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

Very short and front-loaded, with the main action first. The Args and Returns sections are boilerplate but not harmful. Efficient overall.

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 an output schema, so explaining return values is unnecessary. However, with 0% parameter description coverage despite one parameter, the description should provide more context about what 'value' means and how it affects the resonator. It is adequate but incomplete for a tool with no schema description on its only parameter.

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

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

Schema description coverage is 0%, so the description should compensate, but it only restates 'value' vaguely as 'params: value.' It does mention the 0.0-0.5 range, which is also in the schema's minimum/maximum. The description fails to fully compensate for the low schema coverage.

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

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

States a specific verb+resource (set resonator wet/dry balance) with a range, which is clear enough to distinguish it from most siblings. It lacks explicit differentiation from the very similar polynodes_set_dry_wet or polynodes_resonator_switch, but the resonator-specific qualifier helps.

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 polynodes_set_dry_wet or polynodes_resonator_switch. The range (0.0-0.5) is stated but that is a parameter constraint, not usage context.

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

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

Annotations already declare readOnly=false, idempotent=true, openWorld=true, and destructive=false, covering the safety profile. The description adds only 'Returns: JSON confirmation', which is redundant given an output schema exists, and says nothing about what changing the distribution does or any side effects.

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

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

The core sentence is front-loaded and short, but the 'Args: params: value. Returns: JSON confirmation.' boilerplate adds no information and reads as placeholder filler.

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

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

For a single-parameter setter with full annotations and an output schema, the description is minimally adequate. However, it never explains what the frequency distribution concept controls, leaving the agent without meaningful context for the one parameter that matters.

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

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

Schema description coverage is 0% for the top-level 'params' object, and the description's 'params: value' is a tautological restatement that adds no meaning. The only useful constraint (1.0-3.0) duplicates what the schema already specifies.

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

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

The description states a specific verb ('Set') and resource ('resonator frequency distribution'), which is clearest against siblings like polynodes_resonator_balance or polynodes_resonator_switch. It does not explicitly name which sibling it is not, but the resource is distinct enough for an agent to disambiguate.

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 among the many polynodes_resonator_* siblings. Only the numeric range is offered as 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety/idempotency profile is covered structurally. The description adds only 'Returns: JSON confirmation', which is redundant with the output schema, and does not disclose any behavior beyond annotations.

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

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

Very short and front-loaded with the action, with no padding. The boilerplate Args/Returns block is minimal, though the Args line is too terse to be useful.

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 boolean-style switch with an output schema and rich annotations, the description covers the core purpose adequately. But it omits any routing guidance among ~40 siblings and any note that the state value is numeric 0/1, leaving it only minimally viable.

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 description's 'params: state' is a vague and arguably inaccurate restatement, since the schema shows params is an object containing a state field. The actual semantic detail (0.0 = off, 1.0 = on) lives in the schema's nested property description, not the tool description, so the description adds nothing here.

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

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

States a specific verb ('Turn on or off') and a specific resource ('Resonator'), which is enough to distinguish it from the many other *_switch siblings by name. It doesn't explicitly call out how it differs from e.g. polynodes_filter_switch, but the resource naming does the work.

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

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

There is no guidance on when to use this tool versus the other switch tools, no preconditions, and no mention of alternatives. The agent must infer usage entirely from the name.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false and openWorldHint=true, so the mutation profile is covered. The description adds the value range and the 'per layer' scoping, but omits prerequisites (switch state), whether the setting persists, and what 'level' layers actually affect.

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 core sentence is front-loaded and brief, but the 'Args:' and 'Returns:' boilerplate adds little: the Args block just names the sub-fields and the Returns block is made redundant by the existing 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 setter on a complex audio node with an output schema present, the agent still lacks the unit of the frequency, the effect of each layer, and whether ringmod must be switched on. The presence of an output schema excuses the thin Returns line, but the operational gaps remain.

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 nested schema already describes level as 'macro', 'meso', or 'micro' and value as 'Mod frequency (1.0 to 3.0)', yet the description merely restates 'params: level and value' without explaining units, valid layer names, or the meaning of the frequency value. It does not compensate for the reported coverage gap.

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

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

States a specific verb+resource: 'Set ring modulator center frequency per layer (1.0-3.0)'. This distinguishes it from polynodes_ringmod_switch and the other set_* parameter tools, though it doesn't explicitly say how it differs from the sibling switch tool.

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

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

There is no when-to-use guidance, no prerequisite such as whether the ring modulator must be enabled via polynodes_ringmod_switch first, and no mention of alternatives among the many sibling setter tools.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false and openWorldHint=true, so the safety and repeatability profile is covered. The description's only addition, 'Returns: JSON confirmation', duplicates the existing output schema and adds no behavioral context beyond what structured fields provide.

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 first sentence is front-loaded and precise, and the Args/Returns boilerplate is short. The blocks are conventional filler but not wasteful enough to hurt readability.

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 toggle with rich annotations and an output schema, the definition covers what an agent needs to call it. It falls short only on usage context relative to the many sibling effect switches.

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 itself documents the state field with '0.0 = off, 1.0 = on', so the semantics are already available. The description's 'params: state.' restates the parameter name without adding format or value meaning, so it earns only 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 (turn on/off) and resource (Ring Modulator), which cleanly distinguishes it from the sibling polynodes_ringmod_freq that sets the same effect's frequency rather than its power state.

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 toggle this versus other effect switches, nor any mention of prerequisites such as the effect being loaded. The agent must infer usage from the name alone.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered structurally. The description adds only 'Returns: JSON confirmation' and does not disclose that arbitrary addresses can mutate synth state in unrecoverable or unclear ways, nor any validation/error behavior for invalid OSC paths.

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-loads the purpose in one sentence and keeps supporting detail to short Args/Returns blocks; nothing is redundant or padding. The scaffolded 'Args:'/'Returns:' boilerplate is slightly mechanical but not wasteful.

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

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

Annotations cover the safety and world-interaction profile and an output schema exists, so return values need not be explained. With two fully documented required parameters and a stated universal address scope, an agent has enough to invoke it correctly.

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

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

Schema coverage is 100% and both parameters already carry descriptions and an example address, so the schema does the heavy lifting. The description's Args block largely restates the schema fields with no added format, range, or addressing conventions.

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 ('Send a raw OSC message to PolyNodes') and signals the escape-hatch nature of the tool with 'any OSC address', which distinguishes it from the many named setters like polynodes_set_gain. It does not explicitly contrast itself with those siblings, 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?

'Use this for any OSC address' implies the tool is the general-purpose path when a dedicated setter does not exist, but it never states when to prefer the specialized siblings or when to call polynodes_list_osc_addresses to discover valid addresses. 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?

Annotations already declare idempotentHint=true, destructiveHint=false, openWorldHint=true and readOnlyHint=false, covering the safety profile. The description adds only that it returns JSON confirmation, which is minor and largely redundant given an output schema exists; it discloses nothing new about state changes or side effects.

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

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

The core sentence is front-loaded and tight, but the 'Args: params: value.' and 'Returns: JSON confirmation.' blocks are boilerplate that consume space without adding information. Size is small, so the waste is proportionally notable rather than harmful.

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 setter with annotations covering safety and an output schema covering returns, the description states the action and valid range adequately. Only a note on effects timing or related tools 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?

Schema description coverage is reported as 0%, so the description should compensate; it does restate the 10-300 range and the 'value' input inside 'params', but the schema's BPMInput already carries the same range constraint. The 'Args: params: value.' line is boilerplate that adds no semantics about units or 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 ('Set the sequencer BPM') with the valid range, which is enough to distinguish it from siblings like set_playback_rate or set_envelope_time. It does not explicitly differentiate itself from those siblings, but the resource noun 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?

No when-to-use context, no prerequisites, and no mention of alternatives among the many polynodes setter tools. The agent must infer usage entirely from the name.

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

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

Annotations cover the safety profile (idempotent, non-destructive, open-world), so the description is free to add value — and it does, spelling out the enforced value ceilings per level and confirming a JSON confirmation is returned. It still doesn't say what happens if the comb filter is switched off or whether out-of-range values are clamped or rejected.

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

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

Front-loaded and short, which is good, but 'Args: params: level and value' restates the schema and 'Returns: JSON confirmation' restates the output schema, so two of the four lines earn little. Sizing is fine; content economy is mediocre.

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 setter with annotations and an output schema, the essentials are present, but the description omits the dependency on comb_switch and mod_range that an agent would need to sequence this call correctly among its many siblings.

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

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

The schema defines both nested fields, but reported description coverage is 0% at the top level, so the description carries the burden. It names 'level and value' and repeats the ranges that the schema already declares, adding no format or clamping semantics beyond that.

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 ('Set comb filter delay') and gives the valid numeric ranges per level, so an agent can tell it apart from comb_switch or set_comb_mod_range. It stops short of naming those siblings explicitly, which keeps it from a 5.

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

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

No when-to-use guidance, no prerequisites, and no routing to alternatives despite the cluster of adjacent comb tools (comb_switch, set_comb_mod_range). The per-level ranges are the only hint that level selection matters, but the tool never says when to pick macro vs micro or when the comb must already be enabled.

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

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

Annotations already declare the full safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower, but the description adds almost nothing behavioral beyond restating the numeric bound that the schema already enforces. It does not say whether the change applies immediately to a live audio node, whether it is absolute or offset, or what the 'level' selection affects.

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 opening sentence is front-loaded and terse, but the 'Args:' and 'Returns:' boilerplate is largely redundant — the arg names add nothing and the return note duplicates the existing output schema. It is short, but not every line 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 single-parameter setter with annotations, an output schema, and a fully bounded value, the essentials are present. Still missing is any hint about the effect domain (which comb parameter this modulates) or operational prerequisites, leaving an agent to guess how it interacts with polynodes_comb_switch and polynodes_set_comb_delay.

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 description only echoes the parameter names ('level and value') and repeats the 0.0-0.75 bound already encoded in the schema's maximum/minimum. The nested schema itself documents 'macro', 'meso', or 'micro' for level, which the description does not clarify or expand, so it contributes no meaning beyond the structured fields.

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 ('Set comb filter modulation range') with the valid value span, so the agent knows exactly what is being changed. It does not, however, distinguish itself from the nearby siblings polynodes_set_comb_delay or polynodes_set_filter_mod_range, which a one-line qualifier could have done.

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. whether the comb switch must be engaged first), and no reference to any alternative tool. The agent must infer usage purely from the name and the sibling list.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the dry/wet axis semantics and that the call returns a JSON confirmation, which is modest but real added context beyond the structured fields.

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

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

Front-loaded one-line purpose followed by brief Args/Returns blocks; every line is relevant. The 'Returns: JSON confirmation' line is largely redundant given an output schema exists, a minor waste.

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

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

For a single-parameter setter with an output schema and annotations, the description supplies purpose, range, and endpoint meaning. Only a note on which signal chain/node it affects would add more, but nothing an agent needs to call 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?

Schema coverage is reported at 0% (the single param is behind a $ref), so the description must compensate; it does so by restating the 0.0-1.0 range and explaining what each endpoint means ('dry original' / 'wet synthesis'). That is the key semantic the agent needs, though it adds little on units beyond the schema's own bounds.

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

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

States a specific verb ('Set') and resource ('dry/wet balance') with the value endpoints spelled out, so it is clearly distinct from neighbors like set_gain, resonator_balance, or set_filter_freq. It does not explicitly name a sibling it could be confused with, but the resource 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?

No guidance on when to use this versus the many other mix/balance-style setters (set_gain, resonator_balance, cuboid_return_level). Usage is only implied by the tool name; there are no prerequisites or exclusions stated.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, openWorldHint=true, so safety and idempotence are covered structurally. The description adds little: it doesn't clarify what state changes, whether it needs an active agent, or session requirements. 'JSON confirmation' is redundant given an output schema exists.

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

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

Front-loaded verb+resource with the range up front, and the Args/Returns blocks are short. Slightly padded by the redundant 'Returns: JSON confirmation' line.

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 descriptive schema coverage, the description leaves critical gaps: it doesn't define the value semantics or map to the macro/meso/micro level enum, and defers return info to a redundant line. An output schema exists, so return-value explanation is unnecessary, but the description still under-delivers on behavioral and parameter context.

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

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

Schema description coverage is 0%, so the schema relies on titles alone, and the description must compensate. It only restates 'level and value' and the 0.01-0.5 range without explaining valid strings, units, or what envelope time means in this DSP context. It adds almost nothing beyond the schema titles.

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

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

States a specific verb and resource ('Set attack/decay envelope time') and scopes it to macro/meso/micro agents. It distinguishes itself reasonably from siblings like set_gain, set_dry_wet, and set_filter_freq by naming the envelope-time function, though the 'attack/decay' framing is ambiguous versus a per-level value.

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 other parameter-setting siblings, no prerequisites, and no exclusions. The agent must infer usage entirely, and the description does not route to any alternative.

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

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

Annotations declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the description need not repeat those. However, it adds nothing beyond 'Set ... frequency' and 'Returns: JSON confirmation.' It does not disclose whether changing this affects running audio, whether it requires the filter to be switched on, or any rate limits. With annotations covering safety, the bar is lower, but the description still provides minimal behavioral context for a mutation tool.

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

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

The description is short but not well-structured: it mixes the main statement with an 'Args' section that is redundant and a 'Returns' line that is uninformative. The key information (range) is front-loaded, but the extra formatting adds little value and consumes space without earning 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 an output schema and rich annotations, the description is incomplete. It doesn't state whether the filter must be enabled, what the JSON confirmation contains (though output schema exists), or any prerequisites or side effects. Given the parameter count is low and the schema has nested descriptions, the description could have been more helpful about usage context.

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

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

Schema description coverage is 0% because the schema uses $ref and the top-level parameter has no description. The description says 'params: level and value' and repeats the frequency range, but it does not explain the semantics of 'level' (macro/meso/micro) or how the value interacts with other parameters. Since the schema itself defines the nested FilterInput with descriptions for level and value, the description adds only marginal value beyond the structured data, meriting the baseline 3 for zero 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 and resource: 'Set bandpass filter center frequency'. It includes the valid range (80-8000 Hz), making the purpose concrete and distinguishable from siblings like polynodes_set_filter_mod_range or polynodes_filter_switch. It stops short of naming a sibling alternative, but the verb+resource combination is unambiguous.

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

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

The description provides no when-to-use guidance, no prerequisites, and no alternatives. It doesn't mention whether the filter must be enabled first (e.g., via polynodes_filter_switch), whether it requires a specific mode, or when another tool would be more appropriate. It offers only the basic 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?

Annotations already declare readOnlyHint=false, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds little beyond structured data: the range is already in the schema, and 'Returns: JSON confirmation' is redundant because an output schema exists.

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

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

The description is short and front-loads the main action. The Args and Returns sections are terse, though the Args line is awkwardly nested and the Returns line is redundant given the 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 simple setter, the purpose and range are clear, and annotations cover safety. However, the low parameter schema coverage is not offset by the description's vague 'level and value' listing, leaving level semantics unexplained.

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 reported as 0%, so the description should compensate for the nested parameter. It only lists 'level and value' without explaining what macro/meso/micro levels mean or how the value affects the modulation range.

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

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

The description states a specific verb ('Set') and resource ('bandpass filter modulation range') and distinguishes this tool from sibling modulation-range setters like playback rate or comb modulation range. An agent can identify the intended effect 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?

The description gives no when-to-use guidance, no alternatives, and no prerequisites. It is implied that this should be used to set the bandpass filter modulation range, but that is only inferable from the name.

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

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

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description usefully adds the accepted value range and that the call returns a JSON confirmation, but says nothing about permission requirements, per-level side effects, or how gain interacts with solo/other levels.

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

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

The one-line purpose is front-loaded and the Args/Returns blocks are compact and scannable. The Args line largely restates the schema, so it is slightly redundant but not wasteful.

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

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

For a simple idempotent setter, the essentials are present: target scope, valid range, and confirmation of a JSON return (and an output schema exists). It stops short of describing level semantics or interaction with gain_solo, which leaves a minor gap for an agent choosing among the many polynodes setter siblings.

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

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

Reported schema description coverage is 0% for the top-level 'params' wrapper, so the description must carry weight. It does list the three level values and the dB unit, but this mirrors the nested GainInput schema (which already has min/max -80/20 and field descriptions) rather than explaining what a 'macro/meso/micro' level actually controls or how the value is applied.

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 ('Set gain') plus the target scope (macro/meso/micro layer) and the valid dB range, so the agent knows exactly what the tool mutates. It does not differentiate itself from nearby siblings such as polynodes_gain_solo or polynodes_set_dry_wet, which is the only thing keeping it from 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 guidance, no prerequisites (e.g., whether playback must be running), and no mention of alternatives like gain_solo or set_dry_wet. Usage is only inferable from the name and the enumerated level values.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the mutation/idempotency profile is covered externally. The description adds the value constraints (0.3-10 / 0.3-20 / 0.3-30 per granularity level), which is useful, but says nothing about units (is 1.0 normal speed?), clamping behavior out of range, or whether the rate is a multiplier or a tempo-relative setting.

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 action and the key range constraints, then structured Args/Returns. The 'Returns: JSON confirmation' line is nearly content-free, but the overall text is tight with little waste.

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

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

An output schema exists, so the return value need not be explained. Still missing for a mutation tool with openWorldHint: what 'value' means physically (multiplier vs ratio vs semitones) and how out-of-range input is handled. Adequate but with clear gaps.

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

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

Schema description coverage is reported at 0%, so the description must carry the parameter burden, and it does partially: it names the two subfields (level, value) and maps each level to its numeric range. However, it adds no interpretation of the value (units, min/max semantics, what happens out of range), so it only partly compensates.

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 ('Set playback rate for agents') and adds per-level range detail, so the intent is immediately clear. It does not explicitly distinguish itself from the very similarly named sibling polynodes_set_playback_rate_mod_range, so an agent must infer which one 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 statement of when to use this tool, when not to, or which sibling to prefer. The near-identical name polynodes_set_playback_rate_mod_range makes this omission costly, since the agent gets no routing guidance between the two.

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

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

Annotations declare non-readOnly, idempotent, openWorld, non-destructive, but the description adds nothing about persistence, level semantics, or effect. It repeats 'stochastic modulation range' without disclosing behavioral traits beyond the annotations. 'Returns: JSON confirmation' is minimal.

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?

Brief and front-loaded, though the 'Args'/'Returns' block format from a docstring is slightly redundant with structured schema/annotations.

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

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

An output schema exists so return value detail is unnecessary. But with 0% schema description coverage at the top level, and no usage or behavioral context, the description is minimal for a mutation tool in a large sibling set.

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

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

Schema description coverage is 0%, so the description must carry the burden. It only states 'params: level and value' and the range, but the schema itself already defines level enum ('macro','meso','micro') and value bounds (0.0-0.75) via its 'description' fields, even though the top-level 'params' lacks one. The description adds no meaning beyond the schema's own nested descriptions.

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

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

States a specific verb and resource ('Set the stochastic modulation range for playback rate') with the value range. Distinguishable from siblings like polynodes_set_playback_rate (the base rate) and other *_mod_range tools by naming the parameter it modulates.

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

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

No indication of when to use this versus polynodes_set_playback_rate or the other modulation-range setters. The description gives no 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?

Annotations already declare idempotentHint=true, destructiveHint=false, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only 'Returns: JSON confirmation,' which is already implied by the output schema and says nothing about what enabling/disabling actually changes in the audio graph.

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 purpose sentence is front-loaded and short, which is good, but the Args/Returns boilerplate contributes little ('JSON confirmation' is filler given an output schema exists). It is not bloated, but part of it does not 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 toggle with no annotation-level explanation of what is being toggled, the description leaves the agent guessing about the effect on playback rate and tuning scale. The output schema excuses explaining return values, but the core behavioral effect remains undefined.

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 reported as 0% and the description merely restates the parameter name ('params: state'). It does not explain that state is numeric 0.0/1.0, that mapping only appearing in the nested schema. It adds no meaning 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 gives a specific verb ('turn ... on or off') and a specific resource ('tuning scale application on PB rate'), which differentiates it from the many sibling switches (granular_switch, filter_switch, tuning_res_switch). The domain jargon is opaque, but the action and target are identifiable.

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

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

No indication of when to use this switch versus the closely related polynodes_tuning_res_switch or the playback-rate tools. There is no context, no prerequisites, and no alternatives named.

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

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

Annotations already declare idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only 'Returns: JSON confirmation,' which is largely redundant given an output schema exists, and says nothing about required connection state or persistence of the setting.

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 one-line purpose is front-loaded and waste-free, but the Args/Returns boilerplate contributes almost nothing ('params: state', 'JSON confirmation') and pads a very short definition.

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 on/off switch with an output schema, this is minimally adequate: the state polarity is documented in the schema and return values are covered by the output schema. However, what 'tuning scale application' actually affects on the resonator is never clarified, leaving the agent guessing at the audible/functional consequence.

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 reported as 0% at the parameter level and the description only says 'params: state,' which merely restates the schema key. It adds no meaning (e.g., confirming the 0/1 polarity or default) beyond what the agent can read in the schema, so it fails to compensate for the coverage gap.

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

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

States a specific verb (turn on/off) and a specific resource (tuning scale application on the resonator filter), which distinguishes it from the plain resonator switch and the pitch-bend tuning switch among siblings. It never names those siblings, so differentiation requires the agent to already know the family.

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

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

No indication of when to enable versus disable this, no prerequisites, and no reference to alternatives like polynodes_resonator_switch or polynodes_tuning_pb_switch. The agent must infer usage entirely from the name.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=true, and destructiveHint=false, giving a full safety profile. The description adds range and return confirmation, but does not explain what 'reflection force' affects or any side effects. With annotations carrying the safety burden, this is adequate but not rich.

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

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

The description is short and front-loads the core action. The Args and Returns sections are somewhat redundant given the schema and output schema, but they do not bloat the text.

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

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

For a simple setter with rich annotations and an output schema, the description covers the basic purpose and return format. However, it lacks usage context and sufficient parameter explanation, leaving the agent to infer when and how to use the tool correctly.

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

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

Schema description coverage is 0% for the top-level params object, so the description must compensate. It only says 'params: level and value' without explaining the 'level' enum values ('macro', 'meso', 'micro') or confirming that value is normalized. This adds minimal meaning beyond the schema structure.

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 'Set', resource 'White Hole reflection force', and scope 'per layer (0.0-1.0)'. Distinguishes from the sibling blackhole_force by explicitly naming White Hole.

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

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

No indication of when to use this tool versus alternatives, no prerequisites, and no exclusions. The description is a bare setter command with no routing guidance.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety and repeatability profile is covered without the description. The description adds only 'Returns: JSON confirmation', which is thin and partially redundant given an output schema exists; it does not clarify what toggling the 'interactable' actually affects.

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 core sentence is short and front-loaded, but the trailing 'Args:'/'Returns:' docstring block is boilerplate that earns little, especially since an output schema already exists. No wasted verbosity, but no economy of information either.

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?

Output schema and annotations together cover return values and safety, so the definition is technically callable. However, it leaves the distinction from polynodes_whitehole_force and the meaning of the 'interactable' concept unexplained, which matters in a family of 40+ near-identical switch 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?

With reported schema description coverage at 0%, the description must carry the parameter burden, but it only echoes the field name ('params: state'). The meaningful mapping (0.0 = off, 1.0 = on) lives in the schema, not the description, so it adds essentially no semantic value.

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 ('Turn ... on or off') and a specific resource ('White Hole DSP interactable'), which cleanly separates it from both non-switch siblings like polynodes_whitehole_force and the parallel polynodes_blackhole_switch. An agent can identify the operation 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?

No guidance on when to call this versus the many other switch tools, no prerequisites, no mention of sequencing (e.g., relative to polynodes_whitehole_force). The only usage cue is the on/off semantics, which the schema already supplies.

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