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

There are no annotations to supplement the description. The description states it 'returns notes' but does not disclose whether the operation is purely computational, whether it writes to the DAW, or whether there is any randomness or determinism. Side effects and state changes are not mentioned.

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 extremely concise, with no redundant words or unnecessary details. Every sentence contributes either the core purpose or a parameter clarification, making it easy to scan.

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

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

The description does not explain the output format beyond 'returns notes', nor does it cover error handling, parameter interdependencies, or integration with the host project. Given the absence of an output schema and annotations, the description leaves several important gaps for an agent invoking 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?

The description explains some parameters (direction, rate, octaves) and gives their enum values, but it omits several others from the schema, such as chord_pitches, length_beats, start_beats, velocity_base, and accent_downbeats. The schema itself lacks descriptions, so the tool description is the only source, and it is incomplete.

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

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

The description clearly states the tool's function: 'Generate an arpeggio over a chord' and specifies what it returns ('notes for the given length'). This is a specific, actionable verb-object pair that distinguishes it from other generation tools like melody_generate or bassline_generate.

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 does not provide any guidance on when to use this tool versus alternatives, nor does it mention conditions, use cases, or limitations. It only explains what the tool does, not when it should be chosen.

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

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

The description explicitly states the tool 'returns sections with bar counts, roles, and an energy 0..1', indicating a non-destructive, informational output. There are no annotations to supplement, so this disclosure is helpful, though it does not explicitly say whether the project is modified.

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

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

The description is two sentences long, well-structured with semicolon-separated parameter explanations and a clear output summary. No redundant or ambiguous wording.

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

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

The description provides enough context to know what input is needed and what output is expected. It does not mention output schema or relationship to composition tools, but for a self-contained planning utility it is sufficiently complete.

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

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

The description adds meaning to four of six parameters (genre, target_length_seconds, tempo, energy_curve) by explaining their roles in the output. The two remaining booleans (include_bridge, include_buildup) are not mentioned, but their names and defaults make their semantics self-evident.

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

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

The description clearly states a specific verb and object: 'Produce a section list for a song.' It further explains how three key parameters (genre, target_length_seconds, tempo, energy_curve) influence the output, making the tool's distinct purpose unambiguous among many composition and theory siblings.

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

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

The description gives a clear functional usage by explaining how each main parameter affects the result (genre selects form, tempo+length set bars, energy_curve shapes intensity). It does not explicitly name alternative tools or state when not to use it, but the intended scenario of generating an arrangement plan is strongly implied.

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

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

No annotations are provided, and the description does not disclose side effects such as whether an existing clip is replaced, whether file validation occurs, or any other potential mutation beyond adding a clip.

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 to the point, using two sentences to convey the core action and optional parameters without unnecessary verbosity.

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 straightforward import operation, the description provides sufficient context for the main parameters and an example use case. It lacks return type or error behavior, but these are not critical for this tool.

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

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

Explains warp_mode, gain_db, fades, and offset, but leaves start_beats, length_beats, and name unexplained. With 10 parameters and no schema descriptions, partial coverage limits an agent's ability to use all parameters correctly.

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

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

The description clearly states the primary function with a specific verb ('Place') and object ('an audio file as a clip on a track'), distinguishing it from other clip-related tools like midi_clip_add.

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?

Gives a concrete use case for the offset_in_source_beats parameter (trimming silent intros), but does not explicitly state when to prefer this tool over alternatives or mention prerequisites like track existence.

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

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

The description transparently explains the output semantics (diffs and sign meaning), and the compare operation is inherently non-destructive. It does not explicitly state side-effect-free behavior, but the nature of the operation makes that clear.

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 concise and well-structured, using a single sentence to convey purpose, metrics, and sign convention without unnecessary detail.

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

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

The description covers purpose, output metrics, sign convention, and the core operation. It omits parameter-level detail (especially bands) and does not specify output format, but for a simple comparison tool, it is sufficiently complete for an agent to invoke it correctly.

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

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

file_a and file_b are inferable as the two audio files, but the 'bands' parameter is not explained (only defaulted to 10). The schema provides types and required status but no descriptive detail, so parameter meanings are incomplete.

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

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

The description clearly states the tool's purpose: compare two audio files, and it specifies the exact metrics returned (LUFS, peak, DR, per-band spectrum diff) and the sign convention (positive means file_a louder/brighter). This distinguishes it from single-file analysis tools.

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

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

The description implies usage when comparing two audio files, but it does not explicitly name alternative tools or state when to choose this over single-file analyzers like audio_loudness_lufs or audio_spectrum. Guidance is implicit rather than explicit.

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

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

The description does not mention any side effects, read-only nature, or potential modifications to the audio file. Since there are no annotations to supplement this, the description carries the burden and is somewhat lacking in explicit behavioral disclosure.

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 concise, using two sentences to convey purpose, output, method, and reliability. There is no unnecessary detail or repetition.

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

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

For a simple analysis tool, the description covers the key aspects: what it detects, what it returns, the underlying method, and limitations. It does not mention edge cases or error handling, but for this scope it is reasonably complete.

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

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

The schema only defines file_path as a string. The description adds that it is an audio file, which is useful but minimal. It does not elaborate on format, accessibility, or other constraints, so it adds limited 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?

Clearly states the function (detect musical key) and the specific output (root note + mode with confidence). The verb 'detect' is specific and the resource is an audio file, distinguishing it from tempo detection or other analysis 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?

Provides implicit usage guidance by noting reliability on tonal pop/jazz and limitations on percussion-heavy or atonal material. This helps the agent decide when this tool is appropriate, though it does not explicitly name alternative tools for those cases.

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

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

No annotations are present, so the description carries the behavioral burden. It discloses the output format (single BPM with confidence 0..1) and the reliability across music styles, which is valuable. It doesn't state side effects or permission needs, but for a read-only detection operation this is minor.

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

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

Two sentences, zero waste. The purpose, algorithm, parameters, output, and limitations are all covered efficiently, with the most critical information (what it does) front-loaded.

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

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

For a simple detection tool, the description covers the essential aspects: what it returns, how parameters behave, and when it works well. It lacks explicit error-handling or file-format details, but these are not critical for a straightforward BPM detection task. The output schema is absent, so the return description is essential and provided.

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

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

Schema coverage is 0%, so the description must explain parameters. It clarifies bpm_min and bpm_max as a search range with defaults, and identifies file_path as the audio file. While it doesn't specify path formatting or error cases, it adds meaning beyond the bare 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 action (detect BPM) on a resource (audio file) and the method (onset autocorrelation). This clearly distinguishes it from siblings like audio_detect_key (key detection) and audio_compare (audio comparison), leaving no ambiguity about its function.

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

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

Provides explicit conditions for good performance (EDM/pop with steady kicks) and limitations (free-tempo or sparse music), helping the agent decide when this tool is appropriate. It doesn't explicitly name alternative tools for other scenarios, but the context is sufficient for routing.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It reasonably indicates the operation is analytical via 'Measure' and reveals the ffmpeg/loudnorm implementation and a true-peak ceiling. It does not, however, state whether the file is modified, describe return shape, or mention any failure modes 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?

Three short sentences, front-loaded with the core action and output metrics, followed by useful reference targets. There is no filler or redundant restatement of the tool name.

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

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

For a single-parameter read-only measurement tool with no output schema, the description covers the essential metrics and practical targets. It is still somewhat thin on return format, path expectations, and how this compares to related analysis tools, so an agent may need to guess at invocation details.

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

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

Schema coverage is 0% and the only parameter, file_path, is described only by name and type. The description loosely ties it to 'an audio file' but does not specify path semantics, supported formats, or whether URLs/local paths are accepted, forcing the agent to infer these details.

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

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

The description names a specific verb ('Measure'), a clear resource ('an audio file'), and the exact metrics returned (integrated LUFS, true peak/dBTP, dynamic range/LRA). It also names the underlying method (ffmpeg loudnorm filter), making it easy to distinguish from siblings like audio_detect_tempo or audio_spectrum.

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 reference targets (Spotify -14, Apple -16, broadcast -23) clearly imply usage in loudness assessment and streaming/broadcast preparation. However, it does not explicitly state when not to use it or mention any alternative tools for loudness or listening-station tasks.

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

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

With no annotations, the description carries the full burden. It discloses the default band count and log-spaced layout, but doesn't specify output format, units, or whether the entire file is analyzed. The example mentions dB, which could create ambiguity against 'RMS energy' without clarification.

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

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

Two sentences, front-loaded with the core function, followed by a concrete use-case example. Every sentence earns its place with no redundancy.

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

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

The tool is simple and the description covers the main purpose and band defaults. However, with no output schema, the lack of explicit return-format or units is a gap, and the dB example introduces some ambiguity. It's mostly adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the bands parameter's default value and layout, and file_path is self-explanatory. For a two-parameter tool, this is reasonable compensation.

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 ('Return') and resource ('RMS energy per frequency band'), clearly distinguishing it from sibling analysis tools like audio_detect_tempo or audio_compare. The example use case reinforces its spectral-analysis purpose.

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 'Useful for...' sentence gives a concrete scenario (comparing frequency balance to a reference), which clearly implies when to use this tool. It doesn't explicitly name alternatives or exclusions, so it stops short of full routing guidance.

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

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

The description explicitly discloses that adding a lane replaces any existing lane on the same target, which is a key side effect. With no annotations to carry this burden, this disclosure is valuable, though it does not mention failure modes or undo behavior.

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

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

The description is concise and free of extraneous content. Important constraints are packed into short, clear statements.

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

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

The description covers the core action and the replace side effect but omits details such as return behavior, error conditions, and more precise parameter semantics. Given the lack of an output schema and annotations, this leaves some gaps for an agent to infer.

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 defines the allowed target values and the points array structure, which partially compensates for zero schema coverage. However, track_id is not explained, and the semantics of beat, value, and curve are left implicit despite the schema also providing no descriptions.

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

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

The description clearly states the action ('Add an automation lane to a track') and the exact scope of the target parameter, including the supported format for plugin parameters. It also notes the replace behavior, which distinguishes it from related automation 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?

No explicit guidance is given about when to use this tool versus alternatives such as automation_envelope or automation_clear. The description states what it does but not the conditions under which it is the preferred choice.

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

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

No annotations are present, so the description carries the full burden. It states the removal action but does not disclose that this is destructive, whether it is undoable, or whether it affects anything beyond automation lanes. This is a meaningful gap for a mutation tool.

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

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

A single sentence conveys the full action and the optional scoping with no wasted words. The key behavior is front-loaded.

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

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

For a simple two-parameter destructive tool, the description covers the core behavior but omits details such as what values target accepts, return behavior, and safety notes. Since no annotations or output schema exist, some additional context would be helpful.

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

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

The schema describes target as optional and track_id as a bare string. The description adds meaning by explaining that target selects a single lane and omission clears all lanes, and that track_id refers to the containing track. This goes beyond the schema's minimal coverage.

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

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

The description uses a specific verb ('Remove') and resource ('automation lanes') and clearly distinguishes the scoped vs. full-clearing behavior. This differentiates it from siblings like automation_list or automation_add, which do different operations.

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

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

The description implies when to use the tool: whenever automation lanes need to be removed. However, it does not explicitly compare against alternatives or state when not to use it, leaving usage to inference.

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

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

With no annotations, the description carries the full burden and does well: it explains shape semantics (exp_in, exp_out, sine) and discloses the append-or-create lane behavior. It stops short of describing return values or effects on existing lane points, but the core mutation behavior is transparent.

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

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

Three sentences with no filler: purpose first, shape definitions second, lane behavior third. Every sentence earns its place and the most important information is front-loaded.

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

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

Given no output schema and no annotations, the description covers the core operation well but leaves gaps: it does not mention what the tool returns, when to prefer it over automation_add, or whether existing lane points are modified. This is adequate but not fully complete for an 8-parameter 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 coverage is only 13%, but the description adds meaning to the key parameters: it explains what start_value, end_value, start_beat, end_beat, and target do in context, and details shape behavior beyond the enum. It does not elaborate on track_id, though steps already has a schema description.

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

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

The description states a specific action and resource: ramping a target value between beats with configurable shapes. It is clear but does not explicitly distinguish itself from sibling tools like automation_add or automation_clear.

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

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

The description implies its use case via 'Convenience' and the ramp behavior, and the append-versus-create rule offers context. However, it never names alternatives or states when not to use it, so the guidance is implied rather than explicit.

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

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

With no annotations, the description carries the behavioral burden. It discloses the default behavior (all tracks when track_id omitted) and implies read-only via 'List', but does not describe the returned data (e.g., lane names vs. IDs) or behavior for tracks with no automation. There is no contradiction with 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?

A single sentence that front-loads the verb and resource and packs the key conditional (all tracks if omitted) with no wasted words.

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

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

The tool is simple and the description covers scope, but without an output schema it does not state what the returned list contains or how lanes are identified. An agent might still be unsure what fields/values to expect before invoking subsequent automation tools.

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

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

The schema only provides type 'string' with 0% description coverage, so the description must compensate. It does, by explaining that track_id targets a specific track and that omission means all tracks, fully covering the parameter's optionality and effect.

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

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

The description uses the specific verb 'List' with resource 'automation lanes' and clarifies scope ('on a track or all tracks'). This clearly identifies the read-only listing operation and is readily distinguished from sibling tools like automation_add or automation_clear.

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

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

It gives clear parameter guidance: track_id is optional and omitting it lists all tracks. However, it never states when to prefer this over related automation tools or mentions any exclusions, so the when-to-use context is only implied by the verb '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?

The description discloses the primary behavior—adding an aux return plugin and receiving audio from the specified bus—but does not mention potential side effects like overwriting existing plugins or error handling when the track doesn't exist. Given no annotations, this is moderately transparent but not exhaustive.

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

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

The description is two sentences, free of fluff, and logically structured: it states the action, explains the purpose, and provides a practical example. No redundancy.

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

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

For a simple tool that adds an aux return, the description gives sufficient context for an agent to understand when and how to use it, including a typical workflow with send_add. No output schema is needed, and the provided information is complete for its complexity.

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

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

The bus_num parameter is explained with a range (0..15) and its role in routing, while track_id is implicitly clear as the target track. The schema defines constraints, and the description adds semantic meaning beyond the raw values.

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

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

The description clearly states the action: 'Add an auxreturn plugin to a track' and specifies the purpose 'so it receives audio from the given bus number'. It also differentiates from send_add by pairing, making the tool's intent 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?

It provides explicit guidance on pairing with send_add and gives a concrete example for parallel routing (drum tracks send to bus 0, aux-return applies reverb), making it clear when this tool is appropriate.

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

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

No annotations and no statement of side effects, output, or whether the generated bassline is added to a track, returned as data, or rendered. An agent cannot tell what will happen after the call beyond the implied generation.

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

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

Three short sentences; purpose is front-loaded and every sentence adds parametric or scope-relevant meaning. No redundant or filler 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?

The tool is simple enough that the prose may suffice for generation, but missing output/return semantics and workflow context leaves ambiguity about how it integrates with the DAW session. No annotation coverage to fill those 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?

Provides useful extra meaning for roots, feel, scale_intervals, and chord_duration_beats, but start_beats is left undocumented and requiredness of roots/chord_duration is not highlighted. Since schema coverage is only 40%, the description partially compensates but not fully.

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 exactly what the tool does in the first sentence — 'Generate a bassline under a chord progression' — and distinguishes it from melodic/drum/arrangement siblings. The subject and object are explicit.

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

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

No guidance on when to choose this over sibling generation tools (e.g., melody_generate, drum_pattern) or how it fits into a composition workflow. The description explains individual parameters but not use conditions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and allowed kind values, but does not disclose side effects, requirements (e.g., an open project), differences between submix and folder behavior, or reversibility. This is insufficient for a mutation tool.

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

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

The description is a single sentence that efficiently states the core purpose and is front-loaded with the primary action. It contains no filler or redundancy. However, it may be too brief, but it is well-structured and 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 tool with two parameters and no output schema, the description is minimal. It does not explain the semantics of the two kinds, how the bus/folder behaves, or any prerequisites. An agent would need to infer or guess about the behavior of kind=folder, making the description incomplete for reliable invocation.

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

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

The schema has 0% description coverage, so the description must explain both parameters. It mentions the kind enum but does not explain what submix versus folder means. The required name parameter is not described at all. The description adds minimal semantic value beyond the raw 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 ('Create') and a resource ('submix / aux track') with a clear purpose ('other tracks can route to'). It also mentions the kind enum, which distinguishes it from generic track creation tools like track_add. This clearly identifies the tool's function and differentiates it from siblings.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as track_add, aux_return_add, or bus_route. The description does not mention when not to use it, prerequisites, or how it differs from similar track-creation tools. This leaves the agent to infer usage context.

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

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

No annotations, so description must carry side-effect information. It states the routing change but doesn't mention whether it overrides existing sends, requires an existing bus, or is destructive.

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

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

Two concise sentences with the main action first, followed by a concrete example. No unnecessary words.

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

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

Provides enough for a basic understanding but omits important context such as whether the bus must already exist, side effects on existing routing, and error behavior. Sibling tools like bus_create are not referenced.

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

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

Parameter names are somewhat intuitive but neither schema nor description explains expected ID formats, existence requirements, or relationships. Since schema coverage is 0%, description should compensate but doesn't.

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 the action: route a track's output to a bus instead of master. The example with Drum Bus reinforces the purpose.

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

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

Provides an example use case (stacking drums) but does not explicitly state when to use versus alternatives like bus_create or send_add, nor mention prerequisites.

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

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

Without annotations, the description carries the burden and does well by noting it returns the new clip_id and deeply copies MIDI notes. It does not disclose potential side effects like overwriting or validation errors, but the core behavior is transparent.

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

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

Two concise sentences cover the operation, result, and a key detail (deep-copy) without any fluff or redundancy.

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

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

The description provides enough information for an agent to call the tool correctly: what it does, what it takes, and what it returns. No missing essential details are apparent.

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 has no descriptions, but the text explains clip_id as the clip to clone and offset_beats as the delta from the original start. Both parameters are given meaningful context beyond their raw types.

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

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

The description clearly states the verb 'Clone' and the resource 'clip', specifies it operates on the same track, and gives positional detail (start_beats + offset_beats). It is distinct from sibling tools like clip_move or clip_remove by implying a copy is created.

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

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

The description does not explicitly mention alternatives or when to prefer this over other clip operations. It is self-explanatory for its own action, but lacks explicit comparative guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses the return structure (id, kind, name, start, length, plus per-clip details) and implies non-mutating behavior by saying 'List'. It doesn't explicitly state side effects, but for a list operation, that's sufficient.

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

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

The description is a single sentence that front-loads the action, then provides essential return details. No unnecessary words or repetition; it's efficient and well-structured.

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

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

For a simple tool with one optional parameter and no output schema, the description fully covers what the tool does and what it returns. An agent can call it correctly without needing additional 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?

The schema already provides a full description for track_id, including optional behavior and default action. The tool description adds no new information beyond what the schema states, so it meets the baseline for high schema coverage without enhancing it.

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

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

The description uses a specific verb 'List' and resource 'clips' with clear scope ('on a track (or all tracks)') and enumerates return fields. It distinguishes itself from sibling mutation tools like clip_set, clip_remove, and clip_duplicate, which perform different actions on clips.

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 purpose is clear as a read-only enumeration, and no explicit alternative is needed since it's the only clip-listing tool among siblings. However, it doesn't explicitly state when to use it vs. other clip tools or mention exclusions, so it's not a full 5.

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

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

With no annotations, the description carries the burden and does disclose one important behavioral invariant: the clip's length is preserved. It does not state whether the move is reversible, how it affects snap/arrangement context, or what happens if new_start_beats is out of range, but the provided invariant is meaningful.

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

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

Two short sentences, front-loaded with the action and followed by the invariant. No filler.

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

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

For a tool with no annotations and no output schema, the description is thin: it omits return/error behavior and does not clarify when to choose clip_move over clip_set or clip_resize. The core operation is clear, but the surrounding context an agent needs for reliable selection and invocation 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 0%, so the description needed to compensate, but it only reuses the schema's own term 'start_beats'. It does not define what unit beats are in, whether fractional or negative values are allowed, or how clip_id is resolved. 'Length unchanged' is a behavioral hint rather than parameter documentation.

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: 'change a clip's start_beats', and adds a key distinction with 'Length unchanged', which separates it from clip_resize and clip_set. Even the 'Shorthand' prefix signals it is a focused convenience operation.

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

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

'Shorthand' implies this is a shortcut for a common operation, and 'Length unchanged' suggests when the user wants to reposition without altering duration. However, it never names alternatives such as clip_set or clip_resize, nor gives explicit when-not-to-use conditions.

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

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

With no annotations, the description carries the behavioral burden. 'Delete' makes the destructive nature clear, but it does not state whether deletion is permanent, whether it is undoable, or whether related automation/routing is affected. This is minimal but not misleading.

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

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

The description is a single efficient sentence with no filler. The core action and target are front-loaded, and every word earns its place.

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

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

For a one-parameter delete tool, the description is mostly adequate: it names the action and the required identifier. However, with no annotations and no output schema, it leaves out details about reversibility, side effects, and expected response, so it is only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only restates that the operation is 'by id', adding little beyond the parameter name clip_id. It does not explain the expected format of the id or how to obtain it (e.g., via clip_list).

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 'Delete a clip by id' uses a specific verb (Delete), a clear resource (clip), and the identifying mechanism (by id). This distinguishes it from sibling tools like clip_duplicate, clip_move, and clip_resize without needing to open the schema.

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

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

There is no guidance about when to use clip_remove versus alternatives such as track_remove, clip_duplicate, or clip_list. It does not mention prerequisites like obtaining a clip_id, nor does it explain what happens if the clip does not exist.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does explain the non-obvious anchor semantics precisely: which edge stays fixed and which edge moves. However, it does not disclose whether resizing trims or stretches clip content, whether the operation is destructive or undoable, or any side effects on the clip's audio/MIDI data.

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

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

Two compact sentences with the core operation front-loaded and the anchor behavior explained densely. Every sentence earns its place; there is no fluff or repetition of 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 3-parameter mutation tool with no annotations and no output schema, it covers the required inputs and the key behavioral choice (anchor). But it omits important outcome details: what happens to the clip's content when resized, any constraints on new_length_beats, and whether the operation is reversible or returns confirmation. An agent can invoke it, but not fully predict the result.

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

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

Schema description coverage is 0%, so the description must compensate. It adds real semantic value for anchor, explaining what 'start' and 'end' actually do, and confirms length is in beats. But clip_id is only named, and new_length_beats has no stated constraints or detail about how the length change affects the clip's content.

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: 'Change a clip's length.' It goes beyond the name by explaining the two anchor modes, which clearly distinguishes it from sibling clip operations like clip_set, clip_move, clip_duplicate, and clip_remove. Not a tautology.

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 versus alternatives such as clip_set, clip_move, or clip_remove. The intended use is implied by 'change a clip's length,' but there are no explicit conditions, exclusions, or alternative routing. The anchor explanation is parameter behavior, not usage context.

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

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

With no annotations provided, the description must disclose behavioral traits, but it only says 'Modify', which is minimal. It doesn't mention return values, side effects, whether it overwrites existing values, or any prerequisites like the clip existing. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is concise and front-loaded: the purpose and instruction come first, followed by per-type field lists. No filler or redundancy. Every sentence earns its place.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description is incomplete. It clarifies per-type applicability but omits parameter meanings, return behavior, error conditions, and side effects. The agent would need to infer too much about how to call it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It adds value by listing which fields apply to AudioClip vs MidiClip, which is essential. However, it doesn't explain the meaning of each parameter (e.g., what start_beats represents, units, ranges). The field names are self-explanatory to some degree, but detailed semantics are missing.

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

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

The description clearly states 'Modify any field on an existing clip', a specific verb and resource. It lists the editable fields per clip type, distinguishing it from sibling tools like clip_move or clip_resize, though it doesn't explicitly name them. It's unambiguous about its core purpose.

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 instruction 'Pass only fields you want changed' gives clear usage guidance, implying partial updates. It also separates AudioClip and MidiClip fields, helping the agent know which parameters are valid for each type. However, it doesn't explicitly say when NOT to use it or name alternatives like clip_move for repositioning.

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

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

With no annotations, the description must fully disclose behavioral traits. It mentions 'revert in Waveform' but does not explain what exactly is reverted, the side effects on the project or files, whether it is destructive, any prerequisites (like Waveform being open), or the return value. 'Dispatch' is vague about the underlying action. This is insufficient for a tool with no annotation support.

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 concise at two sentences, with no wasted words. It front-loads the core action and then provides a practical benefit. It could be slightly more structured (e.g., listing parameters) but it is appropriately sized for its purpose.

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

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

Given the tool has 7 parameters, no annotations, and no output schema, the description is far from complete. It omits parameter semantics, behavioral details, return values, and error conditions. An agent would not know how to properly invoke this tool beyond the basic intent. The description only covers the 'why' but not the 'how'.

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 has 0% description coverage, so the description must compensate for all seven parameters. It does not mention any parameter except implicitly the composer (via the list), but provides no meaning for seed, tempo, key_mode, key_root, out_path, or target_seconds. The description adds no value to parameter understanding beyond the bare schema fields, which themselves have no descriptions.

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

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

The description clearly states the action: dispatch one of three named generative composers and revert in Waveform in a single call. It explicitly names the composer options (jazz/synthwave/lofi), which matches the schema enum, and contrasts with the separate compose tools among siblings by combining compose with revert. This distinguishes it from siblings like compose_lofi_generative or compose_jazz_generative.

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 a clear context: it is for iteration, specifically to avoid the 'compose-then-manually-revert dance.' This implies when to use it (during iterative workflows where a revert is needed) but does not explicitly state when not to use it or name the alternative tools. It provides a strong reason for selection but lacks explicit exclusions.

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

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

With no annotations, the description carries the full behavioral burden. It discloses a critical manual requirement (loading the SFZ in sforzando once), explains why (state not preserved in the .tracktionedit writer), and states that the tool returns a manual_step_required note. This is strong transparency for a compose tool, though it does not mention side effects or output file behavior.

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

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

The description is dense but efficient: both sentences earn their place, with the real-instrument distinction and signal chain front-loaded and the manual step explained immediately after. Slightly long due to the detailed chain, but no wasted words.

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

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

The description covers the core purpose and the essential manual caveat, but with no output schema and no annotations, it leaves the required out_path parameter unexplained and does not state what the tool ultimately writes or returns beyond the manual_step_required note. Adequate for a specialized compose tool, but incomplete for fully reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented seed, tempo, and out_path parameters. It provides no parameter-level guidance at all, not even clarifying what out_path should point to. This is a significant gap.

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

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

The description names a specific verb and resource ('Djent track using REAL VST3 instruments + amp/cab simulators') and explicitly contrasts with 'synthetic 4OSC', distinguishing it from the sibling compose_djent_track. The signal chain is concrete enough that an agent knows exactly what this tool produces.

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 'instead of synthetic 4OSC' phrase gives clear context for when to choose this tool over a synthetic composition path. It does not explicitly name sibling tools or provide when-not-to-use guidance, but the real-versus-synthetic distinction is an effective selection cue.

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

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

With no annotations, the description provides some transparency about the musical output (form, tracks, tempo) but does not disclose side effects, such as whether it creates a new track, overwrites existing content, or renders to a file. The behavior beyond generating musical ideas remains implicit.

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

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

The description is a single, well-structured sentence that efficiently conveys genre, key, form, track list, and tempo. It avoids fluff and presents information in a compact, readable manner.

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

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

Given the lack of schema descriptions and annotations, the description is incomplete. It details the musical content but omits crucial operational context: parameter meanings, output format, destination (out_path), and any session impact. The agent cannot fully understand the tool's behavior from this description alone.

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

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

The description does not explain any of the three parameters (seed, tempo, out_path). It mentions 110 BPM but does not link it to the tempo parameter. The purposes of seed and out_path are entirely unaddressed, leaving parameter semantics undefined.

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

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

The description clearly states the tool generates a progressive metal/djent instrumental in B minor, with a specific form and track list. It is distinct from sibling composition tools by specifying genre, key, form, and arrangement details.

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

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

The description implies usage for djent composition but does not explicitly differentiate from alternatives like compose_djent_real or other genre-specific composers. No direct when-to-use vs. when-not-to-use guidance is provided.

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

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

With no annotations, the description carries the behavioral burden. It does add useful behavior: genre selects drum patterns, bass feels, and mix-balance reference, and energy_curve drives velocity scaling. But it does not disclose side effects, whether the song is rendered/saved, or what happens in the DAW beyond composition.

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

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

Two sentences, front-loaded with the core action, and no filler. The long primitive list is somewhat heavy but earns its place because it clarifies what the tool wires together.

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

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

This is a complex 8-parameter composition tool with no annotations and no output schema, yet the description omits output/return behavior, out_path semantics, and any comparison to the many sibling compose tools. It provides a partial picture but leaves important operational 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%, so the description must compensate. It explains genre and energy_curve, but says nothing about the required out_path or the meaning of root, mode, seed, tempo, and target_seconds. Most parameters remain dependent on their names and defaults.

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

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

The description clearly states a specific action — building a song bottom-up from composition primitives — and identifies the exact primitives involved. This distinguishes it from both individual primitive generators and the higher-level compose_* sibling 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 implies a use case: when you want a song assembled from primitives rather than generated as a single higher-level action. However, it never explicitly says when to prefer this tool over compose_synthwave_generative, compose_variations, or the other compose siblings, and it offers no exclusion 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?

With no annotations, the description carries the full behavioral disclosure burden. It richly explains what the tool will generate: bass feel changes, drum comping behavior, ensemble dynamics, and phrase-level details. However, it does not disclose project-level effects such as whether a new track is added or an existing composition is replaced.

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

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

The description is a single dense sentence with no filler, and every clause contributes meaningful musical direction. It is slightly run-on and could be broken into structured points for readability, but it remains efficient.

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

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

For a zero-argument generative tool, the description gives enough detail about output style, instrumentation, and arrangement for an agent to invoke it correctly. The only notable gap is that it does not state what happens to the current project state or what return/confirmation the agent should expect.

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

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

The input schema has zero parameters, so there are no parameter semantics for the description to clarify. The detailed musical description effectively serves as the tool's configuration context, which is appropriate for a no-argument generative tool.

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

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

The description uses a specific verb ('Generate'), names the resource ('jazz/jaunty track'), and gives concrete distinguishing details such as walking bass, Rhodes comping, and vocal-treated piano lead. This clearly separates it from sibling generative tools like compose_lofi_generative and compose_synthwave_generative.

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 'jazz/jaunty' style label and the detailed musical vocabulary make the intended use case clear, and the description implies this tool is for jazz-style generation rather than other genres. It does not explicitly state when-not-to-use or name alternatives, so it stops short of a 5.

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

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

With no annotations, the description discloses that it generates unique tracks using sub-primitives and varying musical attributes. However, it does not state side effects or project-state impact, such as whether it adds tracks or replaces existing material.

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

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

Two sentences with the core action front-loaded and every clause adding relevant distinction or detail.

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

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

The description gives a good sense of what is generated and how it differs from the old tool. It lacks details about required preconditions, return value, or side effects, which is more impactful given there are no annotations or output schema.

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

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

The input schema is empty, so the baseline is high, and the description adds useful meaning about output variability. The reference to 'each seed' is confusing because no seed parameter exists 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 ('Generate') and resource ('lofi track'), and distinguishes itself from compose_lofi_track by emphasizing uniqueness and a generative approach.

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?

Clearly contrasts with the old hardcoded compose_lofi_track, implying use when a unique generated lofi arrangement is desired. It does not explicitly address genre-specific siblings like compose_synthwave_generative, though the genre distinction is self-evident.

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

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

With no annotations, the description carries the burden of disclosure. It does reveal meaningful behavior: it writes a complete multi-track lofi arrangement, supports preset swapping for A/B testing, and saves to the given path. However, it does not disclose whether an existing file is overwritten, whether the current session is modified, or whether factory preset files must already exist.

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

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

Two tight sentences with zero filler. The core artifact and musical details are front-loaded, and the configurable-preset note earns its place by foreshadowing the relevant parameters without repeating schema defaults.

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

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

Given the tool's complexity (8 parameters), no annotations, and no output schema, the description is not complete enough. It omits overwrite behavior, session side effects, dependency on factory presets, and guidance on how to select this over sibling generators. An agent could invoke it, but blind spots remain around side effects and preconditions.

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 75%, so the schema already documents most parameters and the baseline is 3. The description adds useful context that bass/keys/pad presets are configurable, but it does not explain bar count, seed, tempo, or preset filename semantics beyond what the schema already provides.

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

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

The description clearly states a specific action ('Generate'), a concrete artifact ('.tracktionedit file'), and the musical structure (4 tracks, progression, 808 samples, master FX bus). It is easy to tell what the tool does, though it does not explicitly differentiate itself from sibling compose_lofi_generative.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies it is for composing a full lofi track, but it does not help an agent choose between this and the many other compose_* siblings, nor does it state any prerequisites or exclusions.

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

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

The description discloses the generated audio content (rain bed, wind layer, thunder rumbles) and processing hints (lowpass, EQ, low gain), plus the 60 BPM grid. However, it does not explicitly state whether the tool writes a file, overwrites an existing file, or returns a status/result, and with no annotations the description carries the full transparency burden.

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

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

The description is a single compact sentence with a clear colon-separated list of sonic elements. Every phrase adds useful information without redundancy or filler.

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

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

The description gives a good high-level sense of the tool and its output type, but it omits important context such as file-writing behavior, parameter semantics, and any return value. Since there is no output schema or annotations, this is not fully complete for an agent to invoke confidently.

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

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

Schema coverage is only 33% (only 'seed' has a description), and the description does not compensate by clarifying 'out_path' or 'length_seconds'. The 60 BPM note and rain/wind/thunder details give sonic context but do not explain the meaning or interaction of the parameters.

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

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

The description names a specific verb ('Generate'), a concrete output resource ('.tracktionedit'), and a distinct genre/sound ('rainstorm ambient'). It is clearly differentiated from the many sibling composition tools that target lofi, synthwave, jazz, etc.

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

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

The description gives clear context that this is for rainstorm ambient sound generation, including the 'No music' note, which implicitly steers an agent away from the melodic composer siblings. It does not explicitly name alternatives or state when not to use it, so it stops just short of a 5.

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

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

With no annotations, the description carries the full burden and does substantial work: it discloses that output is unique per call, lists the underlying primitives driven, names the varied musical dimensions, gives a tempo range, and explains seed-dependent variation. It does not state whether the call mutates the existing project or creates a new track, but nothing contradicts 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?

Two compact sentences front-load the core action and uniqueness guarantee, then efficiently enumerate variation dimensions and the meaning of seeds. Every sentence earns its place.

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

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

For a parameterless generative tool with no annotations and no output schema, the description provides enough context to understand what will happen: a unique synthwave track is generated with specified musical variability. It could add how the result is delivered or integrated into the project, but the core is covered.

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

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

The tool has zero parameters, so the description has no parameter burden. It references seed-driven variation without exposing a seed parameter, which is slightly ambiguous, but there is no schema gap to compensate for.

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

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

States a clear verb-resource pair ('Generate a unique synthwave track') and identifies the genre and variation dimensions. It does not explicitly differentiate from the closely named sibling compose_synthwave_track, so it stops short of a 5.

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

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

No guidance is given on when to use this tool instead of compose_synthwave_track, compose_lofi_generative, compose_jazz_generative, or compose_from_primitives. The reader must infer usage from the genre and 'unique' framing.

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

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

With no annotations provided, the description must carry the transparency burden. It says 'Generate' but does not disclose whether the tool creates or overwrites files, modifies DAW state, renders audio, or returns a confirmation. Side effects and output behavior are left implicit.

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 the musical structure is useful, but the description is somewhat redundant and ends with promotional fluff ('Showcases the full MCP toolset') that does not help an agent call the tool.

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

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

The description provides rich musical context: key, BPM, bar count, section order, bass feels, and arp themes. However, it omits practical execution details such as out_path semantics, seed behavior, return value, and possible side effects, so it is not fully complete for an agent.

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

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

Schema coverage is only 33%, and the description adds little parameter detail. It mentions 110 BPM and the .tracktionedit output, but does not explain the required out_path parameter or the seed parameter for variation reproducibility.

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

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

The description clearly states the tool's core purpose: generating a 64-bar synthwave instrumental .tracktionedit at 110 BPM in A minor. It also specifies the full song form, which distinguishes it from other composition tools.

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

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

The description gives no explicit guidance on when to choose this tool over alternatives such as compose_synthwave_generative or compose_lofi_track. The closing phrase 'Showcases the full MCP toolset' is not actionable usage 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?

Without any annotations, the description carries the burden of disclosing side effects. It transparently mentions that it saves outputs to numbered files and returns the list of paths, but it does not disclose whether it modifies the current project state, whether it overwrites existing files, or whether it has any destructive or non-destructive side effects. Partial transparency only.

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

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

The description is two sentences, concise, and information-dense. It states the core action, the output behavior, and the intended use case without any fluff or redundancy.

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

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

The description is incomplete given the complexity of the tool. It has four parameters including a nested object (extra_args), but no explanation of how extra_args modifies the composition, what format it expects, or how it interacts with count. It also leaves unclear whether the returned paths are absolute or relative, whether the operation is synchronous, and what happens if the composer fails. These gaps prevent an agent from using the tool confidently in nuanced contexts.

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 has zero descriptions for the four parameters, so the description must compensate. However, it does not explain any parameter: it never mentions composer_name, out_path_prefix, count, or extra_args, nor how they map to the described behavior. The phrase 'N times' vaguely references count, but no direct parameter explanation is given. Since schema coverage is 0%, a score of 1 is warranted.

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

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

The description clearly states a specific verb (run a composer) and resource (composer with multiple seeds), and it distinguishes itself from siblings by emphasizing variation generation and selection, which no other sibling tool does. The phrase 'so you can render all and pick the best' further clarifies its unique purpose.

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

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

The description provides clear context for when to use the tool: when the user wants multiple compositional variations to compare and choose the best. However, it does not explicitly mention when not to use it or name alternative tools (e.g., compose_lofi_track or compose_and_reload), so it lacks explicit exclusions.

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

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

The description discloses that it applies compression, which is a type of audio processing, but does not mention any side effects, such as whether it alters the audio destructively, or whether it affects other parameters. It also does not specify the behavior regarding the amount parameter beyond its 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?

The description is concise and to the point, using a single sentence to convey the purpose and parameter semantics. It is well-structured with the parameter explanation parenthetically.

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

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

The description is complete for a simple tool, but it lacks explicit information about the tool's return value or any additional effects on the project. Given the simplicity of the tool and the context from sibling tools, the description is mostly sufficient.

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

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

The amount parameter is explained with its range and meaning, but the track_id parameter is not described. Since track_id is required and its purpose is inferred from the name, the description covers only half of the parameters.

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

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

The description clearly states that the tool is a gentle bus glue compressor, specifying the type and character of the effect. It differentiates from siblings like 'compress_smash' by using terms like 'gentle' and 'glue'.

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 does not explicitly state when to choose this tool over alternatives, such as 'compress_smash'. However, the name and descriptor 'glue' imply a use case for bus compression to glue mix elements together, but this is not directly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the effect ('aggressive parallel-style compressor') but does not explain whether the operation is destructive, how it modifies the track, or what the result will be. Furthermore, the assertion 'No params — preset values' directly contradicts the input schema which includes a required track_id, undermining trust in the description.

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

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

The description is concise, but the misleading statement about parameters wastes the limited space. It front-loads the purpose but then introduces inaccuracy, making the overall structure counterproductive. A well-structured description would clarify the parameter requirement.

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

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

For a tool with one required parameter and no output schema, the description should at least explain the track_id and the effect of the operation. It does neither, and the misleading 'no params' claim leaves the agent without necessary context to invoke the tool safely and 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%, so the description must compensate by explaining the track_id parameter. It not only fails to explain it but actively claims there are no parameters, making the parameter completely opaque. This is a serious failure to add 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 clearly identifies the tool as an aggressive parallel-style compressor for drum-bus / NY-style smash, which is a specific use case. However, it does not differentiate from the sibling tool compress_glue, which likely serves a similar purpose, so it lacks sibling differentiation.

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

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

The description implies usage for drum-bus/NY-style scenarios but provides no explicit guidance on when to choose this over compress_glue or other compressors. The claim 'No params — preset values' is misleading because the schema requires a track_id, leaving the agent uncertain about how to invoke the tool correctly.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It states the click action and button choices but doesn't disclose side effects, coordinate system origin, or behavior of the clicks parameter. The screenshot-first advice adds useful context, but the tool's potentially destructive nature on a live desktop is left implicit.

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

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

Two short sentences with no filler. The core action is front-loaded, followed by the key usage prerequisite and button options. Every sentence earns its place.

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

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

For a 4-parameter tool with no output schema and no annotations, the description is minimally sufficient but leaves gaps: coordinate system details, multi-click semantics, and safety caveats are absent. The screenshot-first instruction helps an agent avoid blind clicking, but the description could be more complete.

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

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

The description clarifies that x and y are screen coordinates and lists the allowed button values. However, the clicks parameter is never mentioned, and the button enum is already fully defined in the schema. With 0% schema description coverage, this is only partial compensation for the undocumented parameters.

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

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

The description states a specific verb ('Click') and resource ('screen coordinates'), clearly distinguishing this tool from siblings like desktop_move and desktop_key. The purpose is immediately understandable and 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 explicitly instructs to use desktop_screenshot first, providing an actionable precondition and workflow context. It doesn't name alternatives or exclusions, but for a low-level input primitive this is reasonable 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?

Discloses that input is sent to the currently focused window, which is important for predicting side effects. It does not describe repeat behavior of presses/interval or potential focus sensitivity, but these are not safety-critical and are partially inferred from parameter names.

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

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

One concise sentence with illustrative examples and no redundant or filler text. The structure is clean and easy to parse.

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

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

Provides essential context: what the tool does, example input, and focus behavior. It lacks explicit contrast with desktop_type/desktop_click and full parameter explanations, but is sufficient for straightforward invocation in most cases.

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 clarifies 'keys' with examples, but 'presses' and 'interval' are not explained at all. Schema provides no descriptions, so the agent must infer their meaning from names and defaults, leaving incomplete parameter 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?

States a specific action (press) and resource (single key or chord) with concrete examples. Clearly differentiates from sibling tools like desktop_type and desktop_click by focusing on keyboard shortcuts and key chords.

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?

Examples imply common use cases (keyboard shortcuts, navigation), but the description does not explicitly state when to prefer this over desktop_type for text input or desktop_click for mouse actions. Usage guidance is implicit rather than explicit.

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

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

There are no annotations, so the description carries the full behavioral burden. It discloses the key non-effect ('without clicking') and the core action, but does not mention coordinate-space semantics, whether movement is absolute screen position, or that the optional duration controls the movement speed.

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

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

One short, front-loaded sentence with no filler. Every word contributes to the core action and the key exclusion.

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

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

The tool is simple, but with no annotations, no output schema, and 0% parameter description coverage, the definition leaves meaningful gaps: coordinate system/units and duration semantics are undocumented. An agent can probably call it, but not with full confidence about coordinate interpretation.

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 names x and y, but adds no meaning about units, coordinate origin, bounds, or the duration parameter's units/behavior. The optional duration is entirely unexplained beyond the schema default.

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: 'Move the mouse to (x, y)'. The qualifier 'without clicking' clearly differentiates it from sibling desktop_click and other desktop input tools, so an agent can identify the operation precisely.

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

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

The description makes the intended use clear by emphasizing no click is performed, which effectively routes the agent away from desktop_click. It does not explicitly name alternatives or give when-to-use conditions, but the context is sufficient for sibling differentiation.

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?

Without annotations, the description carries the full burden of transparency. It clearly mentions the side effect of writing a PNG file under state/screenshots/ and that it returns the path, which informs the agent about the persistent output and the return value. It does not describe potential overwriting behavior or naming conventions in detail, but the essential behavioral aspects are covered.

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

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

The description is exceptionally concise—two sentences that fully communicate the tool's purpose, output, and usage context. Every word contributes meaning, with no redundancy or fluff.

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

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

The description provides sufficient context for an agent to decide when and why to use the tool, including the output location and the return value. It does not mention potential edge cases like screen resolution, multi-monitor setups, or file overwrite behavior, but these are not critical for typical usage in the given ecosystem. Overall, the description is complete for the intended purpose.

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

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

The input schema already provides complete descriptions for both parameters: 'name' is an optional filename hint, and 'region' is an optional [x, y, width, height] crop. The description does not add any additional semantics beyond what the schema states. Since schema coverage is 100%, the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'capture' and the resource 'the current screen (or a region)', and explicitly mentions the output file location and that it returns the path. This unambiguously distinguishes it from other desktop_* tools like desktop_click or desktop_key which perform actions rather than capturing visual 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?

The description provides a specific and actionable when-to-use: 'to verify that a UI action had the expected effect before sending the next.' This gives clear guidance on when to invoke this tool. It does not explicitly state when not to use it or suggest alternatives, but the sibling list includes other tools like desktop_wait that might be relevant in similar contexts, so a slightly fuller comparison would have been ideal.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it returns screen resolution, without detailing the output format (e.g., pixels, width/height), whether it queries the OS or performs a side effect, or any potential cost. This is minimal disclosure for a tool with no 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?

A single, direct sentence with no filler. It is appropriately sized for a zero-parameter query tool and is front-loaded with the action and result. Every word earns its place.

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

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

Given the tool's simplicity (no params, no output schema), the description is largely complete. It tells the agent exactly what the return value is (screen resolution). However, it could be marginally improved by specifying the format or units (e.g., pixels), which would prevent ambiguity, but this is not a critical gap.

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

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

There are zero parameters, so the baseline is 4. The description does not need to explain parameter semantics since none exist. The schema coverage is vacuously 100%, and the description adds no unnecessary param details.

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

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

The description uses a specific verb ('Return') and a precise resource ('current screen resolution'). It is unambiguous and clearly distinguishes from sibling tools like desktop_screenshot, which capture images. An agent can immediately understand what this tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives. While the purpose is self-evident for a simple query, there is no mention of scenarios or exclusions. For example, it doesn't clarify that this is the correct tool when the agent needs the display dimensions rather than a screenshot.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the literal action and does not mention how interval affects behavior, whether it simulates keyboard input, focus requirements beyond the obvious, or any limitations.

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

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

The description is a single front-loaded sentence with no filler. It is efficient, though the brevity contributes to the lack of behavioral and parameter detail.

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

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

For a tool with no annotations and no output schema, the description is too sparse. It covers the core action but omits interval semantics, input simulation behavior, and any guidance for distinguishing it from related desktop input 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 0%, and the description does not explain either parameter. 'text' is self-explanatory from its name, but 'interval' is ambiguous: its units, whether it is per keystroke, and its behavior are left entirely to inference.

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 ('Type'), a clear resource ('a string of text'), and the target context ('the focused window'). This makes the tool's basic function clear, though it does not explicitly differentiate it from sibling desktop_key.

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

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

No guidance is given about when to use this tool versus desktop_key, desktop_click, or other desktop input tools. The only contextual hint is 'focused window,' which implies a prerequisite but no exclusions or alternative routing.

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

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

With no annotations, the description carries the burden of explaining behavior. It states the core behavior (sleep for the given seconds) and implies no other side effects. It does not mention return value or absence of state changes, but for a wait operation this is implicit and sufficient.

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 extremely concise: two short sentences with no filler. It states the action and the key usage caution, making every word valuable.

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 wait tool, the description is complete enough: it explains the operation and gives a usage preference. There is no output schema needed for a side-effect-free sleep. It could mention why waiting is sometimes necessary, but the current context is adequate.

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

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

The schema already provides the parameter name, type, minimum, and maximum. The description only repeats 'seconds' in the phrase 'Sleep for `seconds` seconds' without adding further semantic detail beyond what the schema supplies, so it stays at the baseline.

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

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

The description clearly states the tool's purpose: to sleep for a specified number of seconds. The verb 'Sleep' and the parameter 'seconds' make the action and resource 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 gives explicit usage guidance: 'Use sparingly' and 'prefer screenshot-then-act', which directs the agent toward a preferred alternative. It does not go into detail about exactly when waiting is appropriate, but the guidance is clear enough for this simple tool.

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

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

With no annotations, the description carries the full burden and does provide useful behavioral detail: density scales note count, length_bars tiles patterns, and the tool returns notes rather than placing them. However, it does not disclose nondeterminism, the effect of seed/humanize on output variation, or any project side effects, and its density range conflicts with the schema's maximum of 1.5.

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

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

The description is compact and front-loaded, with the main purpose in the first clause. It uses terse notation for the role set and density behavior, and every sentence contributes meaning 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?

The core invocation path is covered: required params genre, role, and length_bars are explained, and the return intent is stated. However, this is an 8-parameter generative tool with no output schema and no annotations, so the missing semantics for four optional parameters and the density range inconsistency leave meaningful gaps for an agent deciding how to customize a call.

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

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

The description adds meaningful semantics for role, genre, density, and length_bars, including an explicit role enum and an illustrative density example. But with only 13% schema coverage, it leaves seed, swing, humanize, and start_beats undocumented, and the stated density range "0..1" contradicts the schema's allowable maximum of 1.5.

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

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

The description opens with a specific verb and resource: "Generate drum notes for a section." It further distinguishes itself from sibling generators like melody_generate, bassline_generate, and arp_pattern by focusing on drum patterns, naming the selection mechanism, and noting the notes are for a Sampler track.

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

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

The description clearly indicates when to use this tool: when drum notes for a section are needed, with genre and role selecting from the pattern library. It does not explicitly name alternatives or when-not-to-use conditions, though sibling drum_pattern_list is an obvious complement for browsing patterns.

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

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

There are no annotations, so the description carries the full burden. It clearly implies a read-only list operation but does not disclose return format, pagination, error behavior, or any other behavioral traits beyond the action itself.

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

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

A single front-loaded sentence with no filler. Every word adds meaning, and it is appropriately sized for a zero-parameter list tool.

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

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

For a simple, parameterless read-only listing, the description is essentially complete. It lacks an output schema and does not detail return shape, but the core invocation intent is fully clear.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly adds no parameter information because none is needed.

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

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

The description states a specific verb ('List') and resource ('all available (genre, role) patterns in the library'), making the tool's purpose clear. It does not explicitly name or contrast with the sibling 'drum_pattern', so it stops short of full sibling differentiation.

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

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

Usage context is implied: use this tool when you need to enumerate available patterns. No explicit when-to-use, when-not-to-use, or alternative routing is provided, so guidance is minimal.

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

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

With no annotations, the description carries the full burden. It discloses that it creates a new empty edit, replaces the in-memory Edit, and does not write to disk until edit_save or flush. This clearly communicates the non-destructive-to-disk nature and the in-memory replacement, which is valuable 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?

Two sentences, front-loaded with the core purpose, and each sentence adds distinct value: first states what it creates, second states the persistence behavior. No wasted words.

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

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

For a tool with 7 parameters and only 14% schema description coverage, the description is incomplete. It doesn't explain the parameters beyond a general mention, nor does it specify return values (though no output schema exists). It gives enough to understand the action but not enough to confidently set parameters without additional inference.

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

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

Schema coverage is only 14% (only key_root has a description). The description mentions 'tempo, time signature, and key' but does not map these to specific parameter names or explain defaults, ranges, or formats for the other six parameters. It adds minimal value beyond the schema's defaults.

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

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

The description clearly states a specific verb and resource: 'Create a new empty Edit (song)' and lists what it sets (tempo, time signature, key). It distinguishes from siblings like edit_open and edit_save by emphasizing 'new empty' and the non-persistence behavior.

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

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

The description implies usage (create a new edit) but does not explicitly name alternatives or state when not to use it. The phrase 'Replaces the in-memory Edit' hints at a destructive side effect but does not guide the agent to choose this over edit_open or edit_save. Guidance is implicit rather than explicit.

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

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

With no annotations, the description carries the burden of explaining behavior. It clearly indicates an export/write action to out_path, but it does not mention whether existing files are overwritten, what happens if markers are missing, or what the tool returns.

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

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

The description is concise and front-loaded, immediately identifying the action, output, and source. Every sentence adds relevant detail without unnecessary fluff.

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

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

For a simple export tool, the description covers the essential context: source data, output type, and format options. It lacks minor details such as overwrite behavior and return value, but overall it is sufficient for an agent 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?

The description clarifies the format parameter by listing allowed values and explains that markers should use section labels. out_path is not explicitly defined but is reasonably inferable as the destination file path.

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

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

The description clearly states the tool exports a chord-chart text file from the markers and tempo of the current Edit. It also enumerates the supported formats, making the purpose unambiguous and distinct from related export tools.

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

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

The description implies when to use the tool: when a chord chart derived from markers and tempo is needed. It could more explicitly contrast with edit_export_midi, but the source and output type are clear enough.

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

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

No annotations are present, so the description must disclose side effects. It does not state whether the operation is read-only, whether it modifies the Edit, or whether it overwrites existing files. This leaves important behavioral traits unclear.

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 relatively brief but includes some redundancy: the format details are stated twice ('One MIDI track per Edit MIDI track' and 'Format-1 SMF with the Edit's tempo + time signature in track 0' repeat the same facts). Still, it stays focused and clear 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?

The description gives good context for the output format and use case, but fails to explain the required parameter, leaving the agent without the information needed to construct a valid call. It is adequate for high-level intent but incomplete for execution.

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 only parameter, out_path, has no schema description and the tool description never mentions it. The agent cannot infer what value to provide (file path, filename, extension, etc.), making this a critical 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 clearly states the tool exports all MIDI clips from the current Edit to a Standard MIDI File, with specific output format details. This distinguishes it from other edit export tools like edit_export_chord_chart.

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 useful output details (one MIDI track per Edit track, Format-1 SMF, tempo/time signature in track 0) but does not explicitly state when to prefer this over sibling export tools or when it should not be used.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals the tool is a read-oriented structural dump (non-mutating by implication), notes its heavier nature (performance hint), and enumerates the content (plugin params, clip gain/fade/offset, automation lane counts, master chain). It stops short of explicitly stating 'read-only' or describing response format, but the 'dump' and 'understand' wording strongly imply non-mutation.

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

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

The description is a single, dense sentence that front-loads the core purpose, then adds contrast and usage context. Every clause earns its place; there is no redundancy or fluff.

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

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

Given zero parameters and no output schema, the description adequately covers what the tool returns (the enumerated structural details), when to invoke it (after edit_open, before mutation), and how it differs from edit_summary. An agent has everything needed to decide when to call it and what to expect.

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

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

The tool has zero parameters, so the description need not elaborate on parameter semantics. The baseline for 0 parameters is 4, and the description adds no parameter-specific details (unnecessary). Schema coverage is trivially 100%.

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

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

The description uses a specific verb ('dump') and resource ('current Edit'), and immediately differentiates from sibling edit_summary by noting it is 'Heavier' and includes detailed components. This clearly distinguishes the tool from the lighter alternative, so an agent can select it correctly.

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

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

Explicitly states when to use: 'Use after edit_open to understand a song before mutating it.' This provides a clear temporal and contextual cue, and the contrast with edit_summary implies when the lighter version is appropriate. No ambiguity remains.

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

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

No annotations are provided, so the description carries the burden. It states the core behavior (loading a file into the model) but doesn't disclose side effects like replacing current edit state, failure modes, or whether the load is destructive to unsaved changes.

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

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

The description is a single, concise sentence that communicates the essential action without unnecessary words. It is well-structured and front-loaded with the verb.

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 simple schema, the description covers the basic action but misses important context: what happens to the current edit, whether the file must already be in a specific format, and error conditions. It lacks the context needed to select this among many edit-related tools.

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

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

The schema only provides the parameter name 'path' with type string and no description. Schema coverage is 0%, so the description must compensate. It mentions the file is a '.tracktionedit' file from disk but doesn't explain path format, relative vs absolute, or valid file extensions beyond the 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 clearly states the verb 'Load' and the resource 'an existing .tracktionedit file from disk into the model'. It is distinguishable from sibling tools like 'edit_create' and 'edit_save', though it doesn't explicitly contrast with them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., file must exist) or situations where a different edit tool would be more appropriate.

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

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

With no annotations, the description carries the full burden. It discloses that it serializes and sets a flush target, but it does not explain overwrite behavior, permissions, or what 'flush target' means in practice. This is a save operation, so non-destructiveness is implied but not stated, and the flush behavior is vague.

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

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

The description is two short sentences, front-loaded with the primary action. The second sentence adds a secondary behavior (setting flush target) without redundancy. No wasted words.

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

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

For a simple one-parameter tool with no output schema and no annotations, the description covers the core action but leaves the 'flush target' behavior unexplained. It also does not address potential edge cases (e.g., existing file, path validation). It is adequate but not thorough.

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

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

Schema coverage is 0%, so the description must compensate. It does not explicitly describe the 'path' parameter beyond implying it is the destination file path. It does not clarify whether the path should be absolute/relative, whether the file will be overwritten, or any format requirements. The description adds minimal 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 clearly states the action ('Serialize the current Edit') and the resource (a .tracktionedit file). This distinguishes it from sibling tools like edit_save_stem (which saves stems) and edit_export_midi (which exports MIDI). The purpose 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 implies the tool is used to save the entire current Edit to a .tracktionedit file, which differentiates it from save_stem or export tools. However, it does not explicitly state when NOT to use it or mention alternatives, and the phrase 'Sets the flush target' suggests a relationship with the 'flush' sibling without explanation.

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

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

No annotations are provided, so the description carries the full burden. It states it saves a 'copy' which implies non-destructive behavior, but does not mention potential side effects, file overwrite behavior, or whether the current Edit is modified. This is adequate but not highly transparent.

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

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

The description is a single well-structured sentence that front-loads the core action and usage guidance. It is concise, easy to parse, and contains no redundant information.

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

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

The description covers the main purpose and usage scenario, and mentions two of the three parameters. However, it omits essential details about the required out_path parameter and the relationship between track_ids and track_names, so it is not fully complete for an agent to invoke correctly.

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

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

The description explains track_ids and track_names as lists for selecting audible tracks, but does not explain out_path, which is the only required parameter. It also leaves ambiguous whether track_ids and track_names are mutually exclusive or can be combined. This is a significant gap given 0% schema coverage.

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

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

The description clearly states the tool saves a stem-mix copy of the current Edit with only named tracks audible, and explicitly mentions using track_ids or track_names. It also provides a specific use case (loop for per-track stems) which distinguishes it from related save/render tools.

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

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

The description gives a clear when-to-use instruction ('Use in a loop to produce per-track stems for rendering') and identifies the key parameters. However, it does not explicitly contrast with sibling tools like edit_save or render_stems, so some inference is still needed.

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

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

With no annotations, the description carries the full burden. It clarifies that preserve_pitch does not actually shift audio pitch, which is a useful behavioral note. However, it does not disclose other potential effects (e.g., on tempo automation, playback, or whether changes are global).

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

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

Two sentences with the main action first, followed by a clarifier. No wasted words; every sentence earns its place.

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

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

For a simple tool, it covers the core purpose and the only non-obvious parameter. Missing differentiation from tempo_set and any mention of return or side effects, but those are likely covered by the tool's simplicity. Could be more complete with usage guidance.

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

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

Schema coverage is 0%, so the description must explain parameters. It explains preserve_pitch's informational nature, but does not add detail for bpm (units, range, required). bpm is self-explanatory from name and type, but the description could have stated units explicitly.

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

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

States a clear action (change) and resource (project tempo). It distinguishes from audio_detect_tempo and edit_transpose by implication, but a sibling named tempo_set exists that appears similar; no explicit differentiation is provided.

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 versus alternatives like tempo_set. The description does not mention any exclusions, conditions, or alternative 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?

With no annotations, the description carries the behavioral burden. It indicates a read-only 'Return' operation and lists the summary contents, but it does not explicitly state that no changes are made, nor does it describe behavior when no Edit is open. This is adequate but not fully transparent.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes: action, output type, scope, and content categories are all present.

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

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

For a zero-parameter, no-output-schema tool, this description is largely complete: it tells the agent what the call returns and at what granularity. It could be more explicit about the exact JSON structure or error/empty-edit behavior, but the tool's simplicity makes the current description sufficient.

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

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

The tool has zero parameters, so schema coverage is trivially 100%. The description adds useful context by enumerating what the summary includes (tracks, clips, markers, tempo), which helps the agent understand the meaning of the returned data despite no parameters.

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

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

The description clearly states the action (Return), the resource (current Edit), and the content categories (tracks, clips, markers, tempo). It is specific and immediately understandable, though it does not explicitly distinguish itself from the similarly named sibling edit_inspect.

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

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

There is no guidance about when to use this tool versus alternatives like edit_inspect or edit_create. The description explains what the tool returns but not when an agent should prefer it or what conditions apply.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It states that MIDI notes are transposed, implying a mutating operation, but it does not mention whether the change is destructive, reversible, or whether it has any side effects. The clarification about audio clips is a scope boundary, not a behavioral disclosure.

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 exceptionally concise—two short sentences—with no superfluous content. It front-loads the primary action and then adds a single, relevant clarification. Every word serves a purpose.

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

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

Given the low complexity (one parameter, no output schema, no annotations), the description is largely sufficient. It tells the agent what input is required and what the tool does. It could be enhanced by noting prerequisites (e.g., an open edit) or expected return value, but these are not critical for the tool's basic correct usage.

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

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

The schema has no description for the `semitones` parameter, and the tool description only uses the parameter name without defining its meaning, range, or direction. The description implies the parameter is the transposition interval, but it does not specify whether negative values are allowed or provide any constraints, leaving the agent to infer semantics from the name alone.

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

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

The description clearly states the action (transpose), the target (every MIDI note in the Edit), and the parameter (semitones). It also explicitly clarifies that audio clips are not pitch-shifted, leaving no ambiguity about the tool's purpose.

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 a clear usage boundary by stating that audio clips are NOT pitch-shifted, which helps an agent decide when not to use this tool. However, it does not explicitly name an alternative tool for audio pitch-shifting, so guidance is partial rather than fully prescriptive.

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

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

With no annotations, the description must fully disclose behavior. It says 'Return' multipliers but then says 'Apply uniformly', creating ambiguity about whether the tool mutates the project or simply returns values. It also does not clarify how the sections_plan is obtained or whether the operation has 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?

Two sentences with no wasted words. The core output is stated first, and the musical application is explained efficiently.

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

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

The description covers purpose, target instruments, and musical shape, but with no output schema and no annotations, it should clarify whether the tool reads a current sections_plan, what the returned multiplier format is, and whether it has side effects. The ambiguity around 'apply' leaves a meaningful gap.

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

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

The tool has zero parameters, so the baseline is 4. The description references sections_plan but does not need to explain parameter syntax. It adds enough context about what the multipliers apply to.

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

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

The description clearly states the tool returns per-section velocity multipliers for a sections_plan and identifies the affected instruments (drums, bass, keys, lead). It is specific and understandable, though it does not explicitly differentiate itself from sibling tools like theory_velocity or arrangement_plan.

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

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

The description provides clear musical context for when to use it: to make the ensemble breathe together across intro, verses, chorus/bridge, and outro. It implies usage but does not state exclusions or name alternatives, so it falls short of explicit routing.

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

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

With no annotations, the description carries the transparency burden. It clearly discloses the primary mutation (adds a high-pass filter with frequency and slope), though it does not mention whether the effect chain is appended/replaced or any failure modes.

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

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

Two short sentences with no filler; the key parameters and their meanings are front-loaded and immediately 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 simple 3-parameter mutation with no output schema, the description is largely complete. It covers the operation and the two non-obvious parameters, though a note about where the filter is placed in the chain would add extra 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 has no parameter descriptions, so the description fills in meaning for freq and slope (including valid slope values). track_id is only implicitly explained as the target track, which is still reasonably clear from 'to a track' and the required schema 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?

The description states a specific action ('Add a high-pass filter'), target ('to a track'), and key parameters ('freq', 'slope'). It clearly distinguishes from siblings like eq_low_pass and eq_tilt.

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 purpose is clear enough that an agent can infer when to use it (when high-pass filtering is needed), but it does not explicitly contrast with eq_low_pass/eq_tilt or state when not to use it.

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

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

With no annotations, the description alone carries the burden. It clearly says the tool adds a filter at a frequency, but it does not mention side effects, non-destructive nature, or how the `q` parameter affects behavior. It is accurate but 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?

A single, concise sentence that conveys the essential information without any filler or redundant phrases. It is well-structured and easy to parse.

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

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

For a simple filter operation, the description provides sufficient context: what it does, where it applies (track), and the key parameter. It does not mention output or potential side effects, but given the simplicity of the tool and the lack of an output schema, this is acceptable.

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 explains `freq` explicitly and `track_id` implicitly ('to a track'), but `q` is not mentioned at all. Schema coverage is roughly 66%, which is not high enough to warrant a baseline of 3, and the description does not compensate for the missing parameter.

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

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

The description clearly states the action ('add a lowpass filter') and the purpose ('darkening/muffling'), including the key parameter `freq` in Hz. It also implicitly distinguishes itself from sibling tools like eq_high_pass or eq_tilt by specifying a lowpass filter.

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

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

The description gives the intended use case (darkening/muffling) but does not explicitly state when to use this tool over alternatives (e.g., eq_high_pass) or when not to use it. The guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It explains the brightness parameter but does not disclose whether this adds a plugin, modifies existing EQ settings, is reversible, or what side effects occur. For a mutating tool, 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?

Two short sentences with no filler; the brightness value mapping is front-loaded and compact. Every word earns its place despite the minimal length.

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

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

For a two-parameter tool with no annotations and no output schema, the description covers the main knob semantics but omits the explicit action/resource relationship and any guidance on valid brightness bounds or when to use it. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for brightness (-1=dark, 0=neutral, +1=bright), which is useful beyond the bare number type, but track_id is left undocumented and the valid range or bounds for brightness are not explicit.

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?

Describes a 'Single-knob bright/dark EQ' and defines the brightness scale, which clearly distinguishes it from eq_high_pass and eq_low_pass. However, it lacks an explicit action verb and does not explicitly state that it applies to the track, relying on the track_id parameter to imply the target.

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

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

No guidance is given on when to prefer this tool over eq_high_pass, eq_low_pass, or other processing tools, and no alternatives or exclusions are mentioned. The only usage info is the brightness value mapping, which is parameter semantics rather than tool-selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core behavior (writing the current Edit to a previously opened path) and adds useful context about the rationale (avoiding flicker in Waveform). It does not mention error cases or permissions, but for a zero-parameter flush operation this is reasonably transparent.

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

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

Two sentences, no wasted words. The action is front-loaded, and the usage rationale is provided in the second sentence. Every sentence earns its place.

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

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

For a zero-parameter tool with no output schema and no annotations, the description provides the essential context: what it writes, where it writes it, and when to use it. It could mention what happens if no edit is open, but the 'previously-opened/saved' phrasing implies the prerequisite.

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

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

The tool has zero parameters, so the baseline is 4. There is no parameter information needed in the description, and the schema is empty; nothing is left undocumented.

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

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

The description uses a specific verb ('Write') and a specific resource ('the current Edit to the previously-opened/saved .tracktionedit path'). This clearly defines what the tool does and distinguishes it from other edit-related operations like edit_save or edit_open.

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 explicitly states when to use this tool: 'between batches of mutations'. It explains the benefit (single coherent update, avoiding mid-edit flicker), though it does not name alternatives or explicitly state when not to use it.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It only states the action 'set' without revealing whether the operation is destructive, reversible, requires authentication, or has side effects. It does not describe the expected behavior beyond the immediate mutation, leaving the agent with no insight into potential risks or 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 extremely brief, which could be seen as concise, but it is under-specified to the point of being unhelpful. It lacks structure, front-loading of critical details, or any substantive content. The single sentence does not earn its place because it offers no useful information beyond the tool name.