audacity-mcp-max

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

With no annotations, the description must carry the behavioral burden. It clearly discloses the main side effect—adding labels to the project—and the threshold sensitivity. However, it does not mention what happens to existing labels, whether the operation is undoable, or any other side effects beyond adding labels.

Agents need to know what a tool does to the 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 core purpose. The parameter documentation is minimal and directly useful, with no redundant filler 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 simple one-parameter tool, the description provides enough to invoke it correctly: what it does, what it affects, and what the threshold means. It is slightly incomplete in that it does not address whether existing labels are overwritten or what the tool returns, but these are minor gaps given the tool's low complexity.

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

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

Schema coverage is 0%, but the description fully compensates by explaining the single parameter: its valid range (0-100), its direction of effect ('lower = more sensitive'), and its default value (65). This adds real meaning beyond the bare integer schema definition.

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

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

The description states a specific action ('Find beats'), a clear resource ('selected audio'), and the outcome ('add labels at beat positions'). This distinguishes it from label-only tools and other analysis tools such as analyze_find_clipping or analyze_plot_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 description implies when to use the tool: when the user wants beat positions marked as labels on selected audio. It does not explicitly state when not to use it or name alternatives such as raw_beatsand_measures, so the guidance is only 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 supplies some behavior: the tool reads the current region rather than taking parameters, and it is a read-only analysis rather than a mutation. However, it does not explain how foreground/background are determined, what the result looks like, or what happens if no region is selected.

Agents need to know what a tool does to the 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 present purpose, prerequisite, and use case with no filler. The core action 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 parameterless tool, the invocation requirement is covered, but with no output schema the description should state what the tool returns or displays. The ambiguity of how foreground and background are distinguished also remains unaddressed, leaving the agent with partial 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?

There are zero parameters and 100% schema coverage, so the schema leaves nothing undocumented. The description adds useful stateful context by requiring a prior region selection, which is more than the empty schema conveys.

Input schemas describe structure but not intent. Descriptions should explain 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 identifies the operation (analyze contrast) and the resource (foreground/background audio), and adds a WCAG accessibility use case that helps set it apart from sibling analyze_* tools. It does not explicitly contrast itself with any sibling, so it falls short of full 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?

It gives a clear context ('checking accessibility compliance (WCAG)') and an explicit prerequisite ('Select a region first'). It does not mention when not to use it or name a preferred alternative, so no 5.

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

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

No annotations are provided, so the description carries the full burden. It does usefully disclose the side effect of creating labels. However, it omits important behavior: whether existing labels at those regions are overwritten or duplicated, what label track is affected, and whether the operation is reversible. These are meaningful gaps for a tool that mutates project state.

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

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

The one-sentence purpose is front-loaded and waste-free, and the Args section is structured and terse. Slight redundancy exists because the parameter defaults repeat the schema for both parameters, but the added range/meaning justifies the duplication.

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

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

For a two-parameter tool with no output schema, the description covers purpose and parameters well. Missing is what the created labels look like (names, format), how the tool interacts with pre-existing labels, and what the return value is. These gaps matter for an analysis tool that modifies the label track, but the core calling contract is adequately documented.

Complex tools with many parameters or behaviors need more documentation. 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 schema's bare integer/default properties — and it does. It adds semantic meaning for both parameters: 'Min number of consecutive clipped samples to detect (1-1000, default 3)' and 'Min number of consecutive non-clipped samples to end a region', including the valid range and behavior. This goes well beyond the schema's minimal titles/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?

States a specific verb+resource ('Find clipping in the selected audio') plus a concrete side effect ('create labels at clipped regions'). This makes it clearly distinct from siblings like raw_show_clipping (visual only) and the other analyze_* tools, without needing to inspect their schemas.

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

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

No guidance is given on when to use this tool versus alternatives. It doesn't reference any sibling (e.g., raw_show_clipping, analyze_plot_spectrum) or state conditions under which clipping detection is appropriate, nor any prerequisites like playing or selecting specific audio.

Agents often have multiple tools that could apply. Explicit usage 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 explains the threshold-based algorithm but omits whether labels are added to an existing label track, whether previous labels are replaced, or if the tool requires a selection. Side effects and project modifications are not specified.

Agents need to know what a tool does to the 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 with a one-sentence summary. The arg list is structured and efficient, though it could be more narrative. 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?

Given no output schema, the description should explain what the tool returns. It does not mention the return value or format. The tool creates labels but doesn't specify if it modifies the project directly or returns label data.

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

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

The schema provides 0% description coverage, so the description carries full burden. It clearly explains each parameter (threshold_db, min_silence_duration, min_sound_duration) with units, defaults, and semantic meaning, adding value 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?

The description clearly states it 'automatically label[s] regions of sound separated by silence'—a specific verb and resource. It distinguishes from siblings like 'analyze_beat_finder' or 'analyze_contrast' which perform different analyses.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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. It does not mention prerequisites, appropriate contexts, or suggest 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 carries the full burden. It states that the tool opens a Plot Spectrum window and targets the selected audio, but it does not explain what the window shows, whether it returns any data, or what happens if no region is selected. It is minimally transparent but not rich.

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

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

Two short sentences: the first states the action and target, the second states the required precondition. Every sentence earns its place and the content 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 parameterless UI action tool with no output schema and no annotations, the description covers the essential details: what it opens, what it operates on, and the needed pre-selection. It is slightly incomplete in not explaining the nature of the Plot Spectrum window, but it is sufficient for correct invocation.

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

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

There are zero parameters and no output schema, so the schema itself provides no semantics beyond an empty object. The description adds meaningful context by indicating the tool acts on 'selected audio' and requires a region, which is more useful than the empty schema 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 uses a specific verb ('Open') and a specific resource ('Plot Spectrum window') on the selected audio, so its purpose is clear. It does not explicitly distinguish itself from sibling analysis tools like analyze_contrast, but the named window is distinctive enough to avoid major confusion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 prerequisite: 'Select a region first.' This tells the agent the state required before invoking the tool. It lacks explicit when-not-to-use guidance or named alternatives, but for a zero-parameter UI action this is adequate 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 provided. The description discloses it creates a text file, but does not mention overwrite behavior, permissions, file size limits, or other side effects. Lacks detail for a write operation.

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

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

The description is two sentences plus an args list, with the main purpose upfront. No unnecessary words, efficient structure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 2-param tool, the description covers the basics, but lacks information on output file format (e.g., plain text, CSV) and how to interpret the exported data. Adequate but 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?

With 0% schema description coverage, the description adds meaning: 'Absolute path' clarifies the path parameter, and 'Maximum number of samples to export' explains the limit parameter with its 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?

The description clearly states it exports raw sample data to a text file for analysis, with a specific verb and resource. It distinguishes from sibling analysis tools by focusing on raw data export.

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

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

The phrase 'for analysis' implies use for external analysis, but no explicit comparison to sibling tools or conditions for when to use/not use. 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?

No annotations provided, so the description carries full burden. It transparently explains what it reports (script pipes, age, round trip, client version, sample rate) and that it offers solutions. No behavioral surprises; no contradictions.

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

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

Description is concise (two sentences) and front-loaded: first sentence states core purpose, second expands on specifics. Every sentence adds value with no redundancy.

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

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

No output schema exists, but the description adequately explains what the tool returns (diagnostic info and recommended actions). Given the tool's simplicity and lack of parameters, the description is 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?

Tool has zero parameters (schema is empty, 100% coverage). Description adds no parameter info, which is acceptable. Baseline for 0 params is 4.

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

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

The description clearly states the purpose: check reachability and diagnose failures. It lists specific checks (script pipes, age, round trip, client copy, sample rate) and actionable advice, distinguishing it from sibling tools which are editing/analysis/transport commands.

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

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

Explicitly instructs to run this first when things fail (no response, empty response, timeout, bad export), providing clear when-to-use context. It doesn't name alternatives but the diagnostic role is 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?

The description states the tool is synchronous and returns analysis directly without a job_id, and lists the specific return values (peak level, noise floor, duration, clipping status, recommendation). This provides transparency about the immediate nature and output format. It does not explicitly state it is read-only, but the term 'analyze' implies no modification, and no side effects are 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 concise and well-structured: first sentence states purpose, second clarifies synchronous nature, third lists return values, and final line gives prerequisite. No redundant or vague phrasing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 parameters and output schema, the description provides sufficient context by explaining the return values and prerequisite. It clearly tells the agent what to expect and what to do before calling. The mention of 'auto_ pipeline' is understood from the sibling tool list, and the tool's role as a recommender is 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 input schema has zero parameters, so there is nothing to explain. The description adds no ambiguity about parameters; the empty schema is fully covered.

Input schemas describe structure but not intent. Descriptions should explain 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 analyzes the current audio track and recommends the best auto_ pipeline to use. It specifies the action (analyze) and the resource (current audio track), and names the output (recommendation). This distinguishes it from sibling tools that directly apply effects or perform other 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 includes an IMPORTANT prerequisite: load audio into Audacity before calling. It also implies usage as a decision-support tool before invoking an auto_ pipeline. However, it does not explicitly contrast with alternatives such as calling a pipeline directly or using other analysis tools, leaving some inference to the agent.

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

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

Details async background processing, return of job_id, side effects of verify parameter (extra exports), and the required silence for remove_noise. With no annotations, description fully covers behavioral traits.

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

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

Well-structured with bold heading, pipeline list, parameter args, and important notes. Front-loaded with purpose. Slightly verbose but every sentence adds value.

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

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

Complete for a 2-parameter async tool: explains return value (job_id), monitoring via sibling, parameter details, and prerequisites (room tone). No output schema needed given description.

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

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

Adds significant meaning beyond schema: explains remove_noise uses first 0.5s as noise profile and verify measures before/after with cost. Schema coverage is 0%, so description compensates 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?

Clearly states 'ONE-CLICK AUDIOBOOK MASTERING: ACX/Audible compliant processing' and lists pipeline steps. Distinguishes from sibling auto tools like auto_cleanup_audio by specifying ACX compliance and background job 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?

Explicitly says to use check_pipeline_status for monitoring and warns not to call again if pipeline is running. Provides context for when to use (ACX compliance) but does not mention alternatives among siblings.

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

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

Describes background execution, immediate job_id return, and lists the processing pipeline steps. Also notes side effects of verify parameter (extra exports). Without annotations, this provides solid behavioral context, though it could mention if it requires audio selection.

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

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

Well-structured with clear sections: summary line, usage context, pipeline details, parameter args, and an IMPORTANT note. Every sentence adds value; no filler.

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

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

Given no output schema, description covers return behavior (job_id), monitoring via check_pipeline_status, and pipeline steps. Complete for a background cleanup 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?

Despite 0% schema description coverage, the tool description provides thorough parameter documentation: explains remove_noise uses first 0.5s as noise profile, remove_clicks for vinyl/old recordings, and verify's trade-off. This compensates fully for missing schema descriptions.

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

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

The description clearly states that the tool safely removes noise and artifacts without altering loudness or dynamics, distinguishing it from related effects like normalize and compressor. It uses specific verbs and resource (audio cleanup) and contrasts with 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?

Explicitly specifies when to use (audio levels already good, just cleanup) and when not to (when a pipeline is already running). Provides alternative monitoring tool (check_pipeline_status) and warns about verify parameter impact.

Agents often have multiple tools that could apply. Explicit usage 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 full burden. It discloses async behavior (returns job_id), pipeline steps, consequences of verify (costs extra exports), and the requirement for noise profile if remove_noise is True. Lacks details on error handling or idempotency but covers key behavioral aspects.

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

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

Well-structured with bullet points and a clear pipeline breakdown. Front-loaded with purpose. While not extremely concise, every sentence adds value without redundancy.

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

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

Given 3 boolean params, no output schema, and async behavior, the description explains the pipeline, parameter effects, async nature, and concurrency constraint. It does not detail the job_id format or how check_pipeline_status works, but those are within sibling 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 coverage is 0%, but the description explains all three parameters: remove_noise (uses first 0.5s as noise profile), remove_silence (truncates silences), verify (costs extra exports). Adds meaning beyond raw schema types 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 'Light-touch processing for dialogue and multiple speakers' and differentiates from siblings like auto_cleanup_podcast by noting it's 'Lighter than podcast' and preserves natural conversation dynamics.

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

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

It explicitly says when to use (for interviews, lighter than podcast), provides a warning not to call again if pipeline is running, and directs to check_pipeline_status for monitoring.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals: background execution, job_id return, pipeline steps, noise reduction level, and the requirement for first 0.5 seconds of room tone. It does not explicitly state whether the operation is destructive or modifies the original file, though it implies processing. A slight improvement would be to mention side effects on original audio.

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

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

The description is well-structured with a bolded header, pipeline list, design note, parameter description, and important notes. It is front-loaded with the key purpose. While every sentence adds value, it is slightly longer than necessary, but still 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?

Given only one optional parameter, no output schema, and no annotations, the description is thorough. It explains the pipeline, usage constraints (room tone, concurrency), monitoring via sibling tool, and parameter trade-offs. An agent has sufficient information to invoke it correctly.

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

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

The sole parameter 'verify' is fully explained: 'Measure the audio before and after and report what changed. Costs two extra exports. Set False on very long projects.' Since schema description coverage is 0%, the description adds complete meaning beyond the schema's type definition.

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

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

The description clearly states the tool's purpose: 'ONE-CLICK LIVE RECORDING CLEANUP: Aggressive processing for noisy/field recordings.' It specifies the resource (live recordings) and distinguishes from siblings like auto_cleanup_podcast or auto_cleanup_vocal by targeting 'live' and 'field' recordings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicit instructions: 'Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.' It advises against calling again if a pipeline is already running, and states it is 'Designed for live performances, field recordings, and noisy environments.' This gives clear when-to-use and when-not-to-use guidance.

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

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

Despite no annotations, description fully discloses pipeline steps (DC offset, HPF, NR, compress, loudness check), safety behavior (only reduces peaks), and effects of verify parameter (costs two extra exports). Covers all key behavioral traits.

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

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

Well-structured with front-loaded key info (one-click, background). Pipeline details are technical but justified. Slightly verbose in listing pipeline steps; could be more concise without losing value.

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

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

Given no output schema and low complexity (3 boolean params), description covers purpose, usage, parameters, and behavioral details. Could mention exact return format of verify or job_id, but cross-references sibling tools adequately.

Complex tools with many parameters or behaviors need more documentation. 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 0% description coverage, but description explains each parameter in detail: remove_noise uses first 0.5s noise profile, remove_silence truncates dead air, verify measures before/after and reports changes. Adds significant meaning beyond 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 it's a podcast cleanup tool with broadcast-quality processing, using specific verb 'cleanup' and resource 'podcast'. It implicitly distinguishes from sibling auto_cleanup tools by specifying podcast context.

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

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

Explicitly states to use check_pipeline_status for monitoring, warns not to call again if pipeline is running, provides prerequisites for remove_noise (first 0.5s room tone), and mentions alternative loudness_normalize tool after pipeline.

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

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

Description mentions async execution with job_id, pipeline steps, and noise profile requirement. It explains that verify costs extra exports. However, it does not disclose if the tool is destructive (modifies original audio) or how to access results beyond monitoring.

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

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

Description is well-structured with sections for purpose, pipeline, and args. It front-loads key info but is slightly verbose. Every sentence adds value, though some details could be condensed.

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

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

Given two boolean params and async behavior, description covers pipeline and usage but lacks clarity on final output (e.g., what happens to audio file). No output schema exists, so description should explain result format more fully.

Complex tools with many parameters or behaviors need more documentation. 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 two booleans with defaults (0% description coverage), but description adds meaning: remove_noise uses first 0.5s as noise profile, verify measures before/after and costs exports. This compensates well for lacking schema descriptions.

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

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

Description clearly states it performs 'professional processing for singing and studio vocals' and lists the pipeline steps. It distinguishes itself from sibling tools like auto_cleanup_podcast and auto_cleanup_interview by specifying vocal focus.

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

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

Description explicitly says to use check_pipeline_status to monitor and warns not to call again if a pipeline is running. It also advises setting verify to False on long projects. However, it doesn't explicitly state when to avoid this tool (e.g., for non-vocal material) or compare with alternatives.

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

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

No annotations provided, so description carries full burden. It discloses background execution, job_id return, pipeline steps, and cost implications of 'verify' parameter. No contradictions.

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

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

Well-structured with clear headings and bullet points. Information is front-loaded and each sentence adds value. Could be slightly more concise but still 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?

Covers all essential aspects: purpose, usage pattern, parameter details, pipeline description, monitoring instructions, and warnings. Complete for effective agent 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%, but description adds detailed meaning for both parameters: explains intensity values ('light', 'medium', 'heavy') with effects, and verify with cost trade-off.

Input schemas describe structure but not intent. Descriptions should explain 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 applies a creative lo-fi/vintage effect to audio, with a specific pipeline and results. It distinguishes itself from other effect tools by naming the unique effect and mentioning background execution.

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

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

Explicitly instructs when to use (apply lo-fi effect), what happens (runs in background, returns job_id), and what to use instead for monitoring (check_pipeline_status). Includes a warning not to call again if pipeline is running.

Agents often have multiple tools that could apply. Explicit usage 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 provided, so description carries full burden. It details background execution, job_id return, and a 6-step pipeline with genre-tuning and optional noise reduction. Explains verify cost and that noise reduction is off by default. Very 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?

Well-structured with numbered pipeline steps and separate args section. Every sentence is informative with no fluff. Two paragraphs clearly separate behavior from parameters.

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

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

Explains async flow and monitoring method. No output schema, but description states returns job_id. Could mention output file retrieval but the flow is clear. Complete enough for an async mastering 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 has 0% description coverage. Description fully explains each parameter: style with an enum list, noise_reduce with default and recommendation, verify with cost warning. Adds critical context beyond schema types 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 the tool masters music tracks with genre-tuned settings, using the verb 'master' and resource 'music track'. It distinguishes itself from sibling auto tools by describing a specific pipeline and async behavior returning a job_id.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 warns not to call again if a pipeline is already running, directing to check_pipeline_status. Provides pipeline steps but does not explicitly compare to manual alternatives. The instruction is strong enough for basic usage.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful guidance that this is a polling-style status check, but it does not describe what the status response contains, what statuses exist, or behavior for invalid or completed job IDs.

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

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

The description is three short sentences with no filler. Purpose is first, usage context follows, and the parameter note is minimal and relevant.

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

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

The description is adequate for a simple one-parameter status check and covers when to call it and how often. However, since there is no output schema, the absence of return-value or status-semantics information leaves an agent uncertain about how to interpret 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?

The input schema only provides the parameter name and type, while the description explains that job_id is 'returned by any auto_ pipeline tool'. This adds crucial provenance information beyond the schema and tells the agent where to obtain the value.

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

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

The description clearly states the tool checks the status of a running pipeline and scopes it to 'any auto_ pipeline', so an agent understands the resource and action. It does not explicitly differentiate from the sibling check_transcription_status, but the 'auto_ pipeline' phrasing narrows the intended use enough.

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

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

The description gives explicit when-to-use guidance: after starting any auto_ pipeline, and it recommends polling every 15-30 seconds. It does not state when not to use it or mention alternative status tools, but the context is clear.

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

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

With no annotations provided, the description carries the behavioral burden. It discloses polling expectations and terminal statuses ('complete' or 'error'), which is useful. However, it does not describe the full response shape, behavior on invalid job IDs, or whether repeated calls are idempotent, leaving some ambiguity for a no-annotation tool.

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

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

The description is compact and scannable: a label, a short usage direction, a polling instruction, and a one-line args section. Every sentence is functional, and the critical usage context is front-loaded. No filler or repetitive content exists.

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

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

For a single-parameter polling tool with no output schema, the description covers the essential workflow: when to call, how often to poll, and when to stop. It implies a status field with values 'complete' or 'error,' which is likely enough for an agent. It could be more complete by stating exact response fields or error behavior, but it is adequate for its simplicity.

Complex tools with many parameters or behaviors need more documentation. 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 does so by explaining that job_id is 'The job ID returned when you started the transcription,' which adds provenance and meaning beyond the bare schema property name. This is sufficient for the single required parameter, though a bit more detail on format or where to find it could push it higher.

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

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

The description states a specific verb and resource: 'Check the status of a running transcription job.' It also references the transcription-starting siblings, which clarifies its role in the workflow. However, it does not explicitly distinguish itself from check_pipeline_status or command_status, so it falls just short of full differentiation.

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

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

The description gives clear when-to-use guidance: 'Call this after starting transcribe_audio, transcribe_to_labels, or transcribe_to_file.' It also provides a polling cadence and termination conditions. It does not mention when not to use it or name alternatives, so it lacks the exclusionary guidance of a perfect score.

Agents often have multiple tools that could apply. Explicit usage 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 disclosure burden. It does state the operation and scoping ('from the selected audio') and explains how threshold and spike_width affect detection, but it does not disclose whether the edit is destructive, reversible, or whether a selection is strictly required before invocation.

Agents need to know what a tool does to the 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: one clear purpose sentence followed by a minimal, well-structured Args block. Every line provides useful information, with no filler.

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

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

For a two-parameter effect tool with no output schema or annotations, the description covers the operation, scope, parameter ranges, defaults, and parameter effects. It could be slightly more complete by noting what happens if no audio is selected or whether the operation modifies the clip in place, but as a simple effect it is largely sufficient.

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

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

Schema description coverage is 0%, yet the description fully compensates by explaining each parameter's meaning, valid range, and default: threshold (0-900, higher = fewer clicks removed) and spike_width (0-40, maximum click width). This goes well beyond the bare schema properties.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Remove clicks and pops from the selected audio', which is clear and actionable. It also gives a helpful example context ('vinyl recordings'), though it does not explicitly distinguish itself from sibling repair/cleanup tools like effect_repair or auto_cleanup_audio.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 should be used when clicks or pops are present in selected audio, but it does not state when not to use it or compare it to alternatives. There is no explicit routing guidance among the many sibling cleanup/effect tools, so the usage context is only 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?

With no annotations, the description must disclose behavior. It explains each parameter's effect and includes a warning about normalize=True causing re-peaking. However, it does not explicitly state whether the tool modifies the selected audio in-place or returns a new file, but this is likely implicit for an effect tool. Overall, it is transparent about parameter impacts and pitfalls.

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

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

The description is well-structured with paragraphs and a bullet-like list of arguments, but it is somewhat verbose. It repeats the argument list that appears in the schema, though since the schema lacks descriptions, this repetition is justified. The usage guidance and warning are valuable, but the text could be tightened without losing essential 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 is complete for the tool's complexity. It covers purpose, usage scenarios, parameter semantics, and warnings. It explains when not to use it (mixing vs. mastering) and directs to an alternative (loudness_normalize). Given no output schema, no return value explanation is needed. Nothing critical is missing.

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

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

The schema has no descriptions (0% coverage), but the description text provides clear semantics for each parameter (e.g., 'threshold_db: Level above which compression starts (dB)'). It also explains the default values and gives examples (e.g., 'ratio: Compression ratio (e.g. 2.0 = 2:1)'). This fully compensates for the lack of schema descriptions.

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

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

The description clearly identifies the tool's purpose: 'Apply dynamic range compression. Evens out volume differences.' This is specific and distinguishes it from related effects. It also provides usage scenarios (mastering vs. podcast) and warns against misuse, further clarifying its intended role.

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

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

The description gives explicit guidance on when to use the tool: 'For mastering, use ratio 1.5-2:1...' and 'For podcasts/voice, use ratio 4-8:1...'. It also explicitly contrasts with loudness_normalize: 'Use loudness_normalize() instead for proper LUFS-based loudness control.' This provides clear selection criteria among alternatives.

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

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

No annotations are provided, so the description carries the responsibility for explaining behavior. It states the main effect (moves the cursor) but gives no information about side effects like selection, playback, or undo behavior. For a simple cursor-move this is adequate but not rich.

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

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

The description is two sentences: a clear front-loaded purpose statement and a brief parameter explanation. No redundancy. Every part contributes to correct invocation.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 scalar parameter and no output schema, the description covers the core behavior and parameter meaning well enough for an agent to call it correctly. It does not cover alternatives or edge cases, but those are not essential for this simple operation.

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

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

With 0% schema description coverage, the schema only says 'time' is a number. The description adds the critical unit: 'Position in seconds.' This meaningfully improves parameter understanding, though it does not specify the reference point (e.g., project start) or valid range.

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

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

The description states a specific action and target: 'Move the cursor to a specific time position.' This is clearly distinct from relative cursor movements like raw_cursor_left/right or anchor-based moves like cursor_to_track_start, but it does not explicitly name a sibling to differentiate from.

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

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

The phrase 'specific time position' implies this is for absolute positioning rather than relative navigation or preset positions, but the description does not explicitly state when to use this tool versus transport_set_cursor, cursor_to_rack_start, or raw_cursor_* alternatives. Usage is inferable but not spelled out.

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

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

With no annotations, the description carries the burden of behavioral disclosure and it does state the primary behavior: cursor movement to project end. It does not mention whether selection is cleared or playback is affected, but for a simple cursor command this is a minor gap.

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

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

One short sentence carries all the essential information with no filler. The parenthetical adds useful precision without bloating the description.

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

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

For a zero-parameter cursor navigation tool, the description is nearly complete. The only small ambiguity is what exactly 'last audio' means, but in an audio-project context this is a reasonable shorthand for the end of the final audio clip.

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

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

The tool takes zero parameters and the schema is fully covered at 100%, so there is nothing for the description to add about parameter meanings. Baseline of 4 applies.

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

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

Description uses a specific verb ('Move') and resource ('cursor') with an exact destination ('end of the project') and clarifies with '(last audio)'. This distinguishes it from sibling tools like cursor_to_track_end and cursor_to_project_start.

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

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

The intended use is clear in context: call this when the cursor should jump to the last audio in the project. It does not explicitly name alternatives or exclusions, but the project-vs-track distinction is evident from the tool name and sibling set.

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

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

No annotations are provided, so the description carries the full behavioral burden. It only states the cursor's final position; it does not disclose side effects such as whether the selection is preserved, whether the view scrolls, whether it affects the undo stack, or whether it is a non-destructive read-only action.

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

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

A single, efficient sentence with no redundant words. The core action and target are front-loaded, and the clarification '(time 0)' is immediately useful but not verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 cursor-movement tool, the description captures the essential behavior. It does not elaborate on side effects or return values, but given the low complexity and intuitive semantics, what is present is largely sufficient, with only the missing behavioral details noted above preventing a 5.

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

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

With zero parameters, the input schema is already complete and there is no need for parameter documentation. The description adds useful context by clarifying the exact project start coordinate ('time 0'), which aligns with the baseline 4 for parameterless tools.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Move') and resource ('cursor') with an explicit target ('start of the project (time 0)'). This clearly distinguishes it from sibling tools like cursor_to_project_end, cursor_to_track_start, and raw_cursor_left, and the parenthetical clarifies the exact coordinate.

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

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

Provides no explicit guidance on when to use this tool versus alternatives, nor any mention of when not to use it. The name and sibling list hint at differentiation, but the description does not articulate conditions or exclusions, leaving the agent to infer context.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states the core behavior of moving the cursor, which is positive, but it does not mention edge cases like having no selected track or whether the selection/playhead is preserved.

Agents need to know what a tool does to the 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 fully communicates the action. There is no redundant wording or filler, and the essential target information is front-loaded.

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

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

For a simple, parameterless cursor-movement command, the description is largely sufficient. It omits minor context such as behavior when no track is selected, but the core intent and outcome are clear given the low 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 tool has zero parameters, so the schema provides no semantic information to compensate for. The description adds the relevant semantic context by identifying the target location, which is sufficient for a parameterless command.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Move') and a clear target ('end of the selected track'). It distinguishes itself from sibling tools like cursor_to_track_start and cursor_to_project_end by stating the exact destination.

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

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

No guidance is given about when to use this tool versus alternatives such as cursor_to_track_start or cursor_to_project_end. There is no explicit context, prerequisite, or exclusion, so the agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It communicates the core action (moving the cursor to the track start) and specifies it applies to the 'selected' track, which is useful. However, it does not disclose any potential side effects (e.g., whether selection changes, playback position, or undo behavior). For a simple non-destructive action this is acceptable, but the description adds little beyond the name itself.

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

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

The description is a single, concise sentence that gets straight to the point. It is front-loaded with the action and target, contains no filler, 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 tool with no parameters, no output schema, and a simple action, the description is largely complete. It specifies the target (start of selected track) and the operation. It does not discuss prerequisites or interactions with other tools, but given its low complexity, this is not a significant gap. It could be slightly more explicit about when to use it versus the similar cursor_to_track_end, but the name already differentiates.

Complex tools with many parameters or behaviors need more documentation. 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 does not attempt to describe any parameters, and the schema already confirms there are none. No additional information is needed.

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

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

The description uses a clear verb ('move') and resource ('cursor to the start of the selected track'), which fully specifies the action. It distinguishes itself from siblings like cursor_to_track_end, cursor_to_project_start, and cursor_to_project_end by naming the exact destination. There is no ambiguity about what the tool does.

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

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

The description states the action but provides no explicit guidance on when to use it versus alternatives. It implies usage when you want to jump the cursor to the start of the current track, but it does not mention exclusions or recommend alternatives such as cursor_to_track_end. The context is clear but lacks explicit 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?

With no annotations provided, the description carries the full behavioral disclosure burden. It clearly states that the selected audio is copied to the clipboard and implies the original is left intact, which is important for distinguishing copy from cut. It does not mention clipboard overwrite behavior, but that is reasonably implied by 'copy to clipboard.'

Agents need to know what a tool does to the 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, efficient sentences. The main purpose is front-loaded, and the only added instruction ('Select a region first') is necessary and non-redundant.

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

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

This is a simple zero-parameter operation with no output schema. The description states the action, the object, the destination, and the required precondition, which is sufficient for an agent to invoke it correctly.

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

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

The tool has zero parameters and schema coverage is 100%, so there are no parameter semantics to clarify. The baseline of 4 applies because the description is not required to explain parameters that do not exist.

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

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

The description uses a specific verb ('Copy') with a clear resource ('selected audio') and destination ('to clipboard'). It clearly distinguishes this from sibling tools like edit_cut and edit_paste by naming the copy action and its 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?

The description provides a clear prerequisite: 'Select a region first.' This tells the agent when the operation can be invoked, though it does not explicitly contrast it with related edit tools such as edit_cut or edit_paste.

Agents often have multiple tools that could apply. Explicit usage 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. 'Cut... to clipboard' conveys the core effect (removal and clipboard placement) and hints that a selection is needed. But it does not disclose what happens when no region is selected, that the previous clipboard contents are overwritten, or that the operation is destructive to the source.

Agents need to know what a tool does to the 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, 11 words, zero fluff. The action sentence is front-loaded and the precondition follows naturally. Every word earns its place.

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

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

For a zero-parameter tool this is mostly adequate: it states the action and the key prerequisite. The gaps are minor but real — no failure-mode behavior for a missing selection, no explicit differentiation from the very similar edit_copy, and no return/output expectations (though no output schema exists).

Complex tools with many parameters or behaviors need more documentation. 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 is empty (0 parameters) with 100% coverage, so the baseline is 4 per the rubric. The description's 'Select a region first' usefully documents the implicit input — the current selection state — which is the de facto parameter of this tool.

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

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

States a specific verb (cut), resource (selected audio), and destination (clipboard). The phrase 'to clipboard' semantically distinguishes it from edit_delete (no clipboard) and edit_copy (leaves original intact), though it doesn't name those 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?

Provides a clear precondition — 'Select a region first.' — which tells the agent that a prior selection is required. However, it does not explicitly say when to prefer this tool over edit_copy or edit_delete, and no exclusions or alternative routing are given.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It goes beyond the bare name by stating the clipboard behavior and the selection prerequisite. Still, it does not disclose whether the deletion is undoable or whether any project/undo context is affected, which would be relevant for a destructive edit operation.

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

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

Two short sentences deliver the action, a key behavioral distinction, and the prerequisite with no filler. The main verb and resource are front-loaded in the first sentence.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 edit command with no output schema, the description contains the essential information: what is deleted, that clipboard contents are not changed, and that a region selection is required. It leaves some safety context (undo behavior) implicit, but nothing required to invoke the tool correctly is missing.

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

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

The input schema has zero parameters and 100% schema description coverage, so there are no parameter details the description must add. Per the zero-parameter baseline, the description is adequate without explaining 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?

The description uses a specific verb and resource: 'Delete the selected audio.' It also distinguishes itself from sibling copy/cut tools by explicitly stating 'does not copy to clipboard,' so an agent can tell edit_delete apart from edit_cut and edit_copy even without examining their schemas.

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

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

The description gives a clear precondition: 'Select a region first.' It also implies when this tool is appropriate rather than cut/copy by noting that it does not copy to clipboard. However, it does not explicitly name alternatives or state when to prefer a sibling like edit_split_delete or edit_cut.

Agents often have multiple tools that could apply. Explicit usage 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 for behavioral disclosure. It states the core operation and result but does not mention whether the original audio is replaced, whether the operation is destructive or reversible, or how silence detection is configured. These are significant gaps for an editing 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, front-loaded sentence with no filler. Every word contributes to understanding the action and the result, and there is no redundant restating of the tool name or 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 zero-argument tool this is minimally complete: it identifies the selection target and the outcome. However, it omits routing guidance among the many split-related sibling tools and does not disclose the behavioral consequences of the operation, which leaves some context gaps.

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

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

The tool has zero parameters and the schema description coverage is 100%, so there is no parameter detail for the description to add. The baseline of 4 applies here.

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

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

The description uses a specific verb and resource: split the selected audio at detected silences, creating separate clips. It clearly communicates the operation and result, and somewhat distinguishes itself from silence-removal tools like truncate_silence, though it does not explicitly contrast with the edit_split sibling family.

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

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

The phrase 'at detected silences' implies when this tool is appropriate, but it provides no explicit when-to-use guidance, exclusions, or alternatives. An agent would not know from this description when to choose edit_disjoin over edit_split, edit_split_new, or label_split_regions.

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

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

With no annotations, the description carries the full transparency burden. It does disclose the core behavior: a duplicate is created in a new track, implying the original is preserved. However, it does not state whether the selection is required, whether track properties like gain/pan/effects are copied, or whether the duplicate is independent of the source.

Agents need to know what a tool does to the 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 seven-word sentence delivers the verb, target, and outcome with zero waste. Every word earns its place, and the key action verb 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 parameterless tool with no annotations and no output schema, the description covers the essential outcome. Minor gaps remain — preconditions (selection required) and post-conditions (track position, copied attributes) — but these are small for such a simple action.

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

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

The tool has zero parameters and 100% schema description coverage, so there is nothing for the description to add about inputs. Per the baseline for parameterless tools, this is appropriately handled — the description itself becomes the sole behavioral specification.

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

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

The description states a specific verb ('Duplicate'), a concrete resource ('selected audio'), and a clear result ('into a new track'). This distinguishes it from close siblings like edit_copy (clipboard copy) and edit_split_new (splitting, not duplicating), so an agent can select it correctly without opening schemas.

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

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

There is no when-to-use guidance, no mention of preconditions (e.g., a selection must exist), and no reference to alternatives such as edit_copy or track_mix_and_render_to_new. The description tells an agent what the tool does but leaves the selection decision entirely 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 provided, the description carries the full behavioral disclosure burden. It states only the action and result, but does not disclose whether the operation is destructive, whether it can be undone, what happens with gaps or overlaps, or how it behaves if no clips are selected.

Agents need to know what a tool does to the 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 is front-loaded with the core verb and resource. Every word adds meaning and there is no redundant or filler content.

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

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

Given the tool's low complexity, zero parameters, and no output schema, the description covers the essential invocation context: selected clips and the intended outcome. It does not explain edge cases, but the simple nature of the tool makes the description 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 input schema has zero parameters, so there is no parameter documentation burden for the description. The baseline of 4 applies because the operation relies entirely on the current selection, which the description mentions.

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

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

The description uses a specific verb and resource combination: 'Join selected clips into one clip.' This clearly distinguishes it from the inverse operation edit_disjoin and related splitting tools like edit_split.

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

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

There is no guidance on when to use this tool versus alternatives, no mention of selection prerequisites, and no exclusion of cases like a single selected clip or overlapping clips. The agent must infer the usage from the imperative phrase 'selected clips.'

Agents often have multiple tools that could apply. Explicit usage 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 merely states the action without explaining whether the paste inserts over existing audio, whether it requires a non-empty clipboard, or what side effects it has on the selection. This is a significant gap for a mutating operation.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the action, the object, and the location efficiently.

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

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

For a simple no-parameter tool, the description is largely sufficient to understand the operation. Minor gaps remain about insertion semantics and clipboard requirements, but given the simplicity of the tool, the current level 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 input schema has zero parameters, so the baseline is 4. The description adds value by clarifying that the operation uses the current cursor position as the insertion point, which is relevant implicit context even though it is not a formal 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 uses the specific verb 'Paste' with a clear resource ('audio from clipboard') and destination ('at the cursor position'), making it easy to distinguish from sibling tools like edit_copy and edit_split. No ambiguity about what the tool does.

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

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

The description clearly implies the use case: pasting clipboard audio at the cursor position. However, it offers no explicit guidance on when not to use this tool or how it compares to alternatives such as edit_copy or edit_split. The context is understandable but exclusions are not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys the core in-place mutation (audio is overwritten with silence) but omits important behavioral traits: whether the action is reversible, whether it affects all tracks or only selected tracks, what happens to the selection afterward, and whether it preserves duration. For a destructive edit operation, this is a significant gap.

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

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

A single, front-loaded sentence with zero filler or repetition. It is efficiently worded, though it leans toward under-specification rather than rich conciseness; still, the structure itself is exemplary for what it covers.

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

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

Despite having no parameters, the tool operates in a crowded namespace of edit tools and performs a destructive mutation with no annotations or output schema to supplement the description. The one-line description does not resolve key ambiguities such as track scope, reversibility, or how it differs from edit_delete and truncate_silence, leaving the agent with incomplete information to invoke it appropriately.

Complex tools with many parameters or behaviors need more documentation. 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 (0 parameters), so the 0-params baseline of 4 applies; there is no parameter information for the description to add. The description appropriately says nothing about arguments because none exist.

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

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

The description states a specific action ('replace') and resource ('the selected audio'), with the 'with silence' qualifier making the result unmistakable and distinguishing it from deletion or trimming. It does not explicitly contrast with sibling tools like edit_delete or truncate_silence, so it falls short of a perfect score, but the core purpose is clearly conveyed.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 the many similar edit tools in the sibling list (edit_delete, edit_trim, edit_cut, truncate_silence, label_silence_regions). No context, exclusions, or alternatives are mentioned, leaving selection entirely to the agent's 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 disclose key behavioral traits: the operation happens in place and does not create a new track. It stops short of detailing undo behavior or selection after-effects, but for a zero-parameter edit command this is solid coverage.

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

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

One sentence with no filler. The verb and target are front-loaded, and the parenthetical adds the key behavioral constraint efficiently.

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

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

For a zero-parameter command with no output schema, the description supplies everything needed: operation, target, split points, and track behavior. There are no missing inputs or return-value expectations to clarify.

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

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

The tool has zero parameters and the schema confirms this, so there are no parameter semantics to document. The description appropriately adds no invented 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 action ('split'), a specific target ('the clip'), and precise split locations ('cursor position or selection boundaries'). The phrase 'in place, no new track' clearly distinguishes it from siblings like edit_split_new and edit_split_cut.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context for when this tool is appropriate: splitting at the cursor or selection. The 'no new track' clause is an implicit exclusion that contrasts with edit_split_new, though it does not name alternatives explicitly.

Agents often have multiple tools that could apply. Explicit usage 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 to rely on, the description carries the behavioral disclosure burden. It clearly states the key side effect: audio is cut but silence remains, so the gap is not closed. It does not mention clipboard behavior, which separates split-cut from split-delete, but the core destructive 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?

A single, well-structured sentence states the action and the critical caveat in a parenthetical. Every word earns its place, and the key distinction 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, parameterless operation, the description is nearly complete: it identifies the target and the resulting timeline state. The only minor gap is that it does not explicitly state whether the cut audio is placed on the clipboard, which matters when distinguishing from edit_split_delete or when preparing to paste.

Complex tools with many parameters or behaviors need more documentation. 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 the description has no parameter meaning to add. The baseline for a parameterless tool is 4, and no further parameter documentation is needed for an agent to invoke it 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 states a specific verb ('Cut'), a resource ('selected audio'), and the defining behavior ('without closing the gap... leaves silence where audio was'). This clearly distinguishes it from siblings like edit_cut and edit_delete that would close the gap or remove time.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage context clear: use this when you want selected audio removed but the timeline position preserved as silence. It does not explicitly name alternatives or exclusions, but the condition 'without closing the gap' is sufficient guidance for choosing among the split/edit siblings.

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

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

No annotations are provided, so the description carries full behavioral disclosure. It transparently states that the operation deletes audio and leaves silence, which is the key behavioral trait. It does not mention undo or other side effects, but the destructive nature is evident from 'Delete', and the silence behavior is clearly disclosed.

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

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

The description is a single sentence that front-loads the core action ('Delete the selected audio') and immediately clarifies the distinguishing detail. There is zero fluff 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 tool with no parameters and no output schema, the description fully explains the operation's effect on the selected audio. It is complete enough for an agent to understand exactly what will happen when the tool is invoked.

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

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

The tool has zero parameters and the schema coverage is 100% (since there are no properties). Per the baseline for 0-parameter tools, the description need not add parameter semantics, and it appropriately does not.

Input schemas describe structure but not intent. Descriptions should explain 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 'Delete' and the resource 'the selected audio', and explicitly distinguishes the behavior by noting it does not close the gap but leaves silence. This clearly differentiates it from sibling tools like edit_delete or edit_cut, which likely close the gap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 intended use case (when silence should remain after deletion) but does not explicitly name alternatives or provide when-not-to-use guidance. An agent can infer usage, but explicit routing to siblings like edit_delete is missing.

Agents often have multiple tools that could apply. Explicit usage 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 must explain side effects, but it is ambiguous whether the original audio is preserved or removed, and whether multiple tracks are created. It only says 'a new track' without clarifying the exact split behavior or how the selection is affected.

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

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

The description is a single, clear sentence with no unnecessary words, making it easy to parse and understand.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 sufficient for a simple tool, but it does not mention prerequisites like having an active selection or how it handles multiple tracks. For such a straightforward operation, the description is mostly complete, though a note on distinctions from similar tools would enhance usability.

Complex tools with many parameters or behaviors need more documentation. 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 no parameters, and the description correctly relies on the current selection with no need for input. Since the schema already covers the absence of parameters, the description adds no additional requirements.

Input schemas describe structure but not intent. Descriptions should explain 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 (split), the target (selected audio), and the outcome (a new track at selection boundaries). It effectively distinguishes this tool from siblings like edit_split or edit_split_cut by specifying the creation of a new 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 does not explicitly compare with sibling tools like edit_split or edit_split_cut. While the phrase 'into a new track' implies a distinct behavior, it does not state when to prefer this tool over the others, leaving the choice 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 provided, the description carries the full burden of behavioral disclosure. The parenthetical 'delete everything except selected region' explicitly communicates the destructive effect, leaving no ambiguity that this tool removes audio. It could add more context about prerequisites such as requiring an active selection, but the core behavior is transparent.

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

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

The description is one tight, front-loaded sentence. The parenthetical adds immediate clarity without redundancy or filler. Every word earns its place.

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

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

For a zero-parameter tool with no output schema, the description is nearly complete: it states the operation and its result. It only omits an explicit mention that a selection must already exist, but this is strongly implied by the wording and the tool name.

Complex tools with many parameters or behaviors need more documentation. 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 to document. The standalone baseline for zero-parameter tools applies, and the description does not need to compensate for any schema gaps.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Trim') and resource ('audio outside the selection') and clarifies the exact behavior in parentheses: 'delete everything except selected region.' This clearly distinguishes it from sibling tools like edit_cut or edit_delete, which target the selected region rather than everything outside it.

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

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

The description clearly implies when to use the tool: when a selection exists and the user wants to keep only that selected region while discarding all other audio. It does not explicitly name alternatives or exclusions, but the behavior is specific enough that an agent can infer the correct usage context.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It communicates that this is an effect application, but does not disclose whether the operation is destructive, whether it requires a selection, whether it is undoable, or what happens when no audio is selected. Parameter semantics are useful but are not 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 short, front-loaded with the one-sentence purpose, and uses a clear Args block. Every sentence contributes either purpose or parameter meaning, with no filler or redundant restatement of the tool name.

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

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

For a simple two-optional-parameter effect, the parameter documentation is adequate. However, the description omits the operational context: what the effect applies to, any preconditions, and what consequences or errors may result. This is a moderate gap, especially with no annotations or output schema to fill it.

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

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

Schema description coverage is 0%, so the description must compensate, and it does by explaining both parameters: fade_type maps 0/1 to fade up/down and curve maps 0/positive/negative to linear/exponential/logarithmic. The curve explanation is somewhat coarse, but it adds real meaning beyond the bare schema titles 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 states a clear action ('Apply') and resource ('an adjustable fade'), with 'curve control' signaling a distinct capability beyond simple fade-in/out siblings. It does not explicitly name sibling alternatives, but the wording and parameter hints differentiate it from tools like effect_fade_in and effect_fade_out.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 only implied by 'adjustable fade' and 'curve control'; an agent can infer it is for custom fades rather than fixed ones. However, the description does not explicitly say when to choose this vs effect_fade_in, effect_fade_out, or effect_studio_fade_out, and it offers no exclusions.

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

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

No annotations exist, so the description carries the full burden. It says 'Amplify the selected audio' but does not disclose whether the original audio is modified in place, whether the operation is undoable, or what happens if there is no selection. That is a significant transparency gap for a mutation tool.

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

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

The description is compact and front-loaded: the action and selection prerequisite appear first, followed by a terse Args block. Every sentence contributes meaning with no filler.

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

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

For a single-parameter audio effect, the description covers the operation, the selection prerequisite, and the full ratio semantics. It does not explicitly state the return value or confirmation behavior, but the absence of an output schema makes that a minor gap.

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

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

The schema only lists a number with a default, while the description explains the ratio semantics with examples, the 'Must be > 0' constraint, and the default. This fully compensates for the 0% schema description 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?

Description opens with a specific verb and resource: 'Amplify the selected audio by a ratio.' This clearly states what the tool does and distinguishes it from sibling effects like fade, reverb, or normalize.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit prerequisite: 'Select audio first.' This is clear context for proper use. It does not, however, name alternative effects or say when not to use it, so it stops short of full 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 present, so the description carries the full behavioral burden. It discloses the trigger mechanism, control-track placement, and selection requirement, but it does not state whether the effect is destructive/undoable, how the control track is treated, or what the resulting output will be.

Agents need to know what a tool does to the 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 well-organized: purpose, setup steps, then a single Args block. It front-loads the core behavior, avoids redundant prose, and every line contributes useful information.

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

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

For a 7-parameter optional effect with no annotations or output schema, the description covers the core operation, all parameter semantics, and required setup. The main gap is the lack of detail about reversibility and the exact scope of modification (track vs. clip), which leaves a small but non-fatal ambiguity.

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

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

All seven parameters are documented in the Args block with meanings, ranges, and defaults, fully compensating for the 0% schema description coverage. For example, threshold_db is explained as 'Threshold for duck trigger in dB (-100 to 0)' rather than being left as a bare numeric property.

Input schemas describe structure but not intent. Descriptions should explain 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: 'automatically reduce volume when audio is detected on another track.' This clearly identifies the sidechain-ducking behavior and separates it from other effect tools like amplify or fade without requiring schema inspection.

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

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

The description provides concrete usage context: place the control track above the track to duck and select the target track before running. It does not explicitly name alternatives or when-not conditions, but the intended use case is clear enough for an agent to select this tool over sibling effects.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates what the tool does and lists parameters. It does not state whether the effect is destructive, whether it applies to the current selection, how the gain interacts with the other parameters, or what happens when all values are left at their defaults.

Agents need to know what a tool does to the 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: a one-sentence purpose followed by a clean argument list. It avoids unnecessary prose, though the phrase 'simple tonal shaping tool' adds only modest value and the argument list partially mirrors the schema field names.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 parameters are fully documented, which is the most critical information for calling the tool. However, with no annotations and no output schema, the description is thin on how the effect behaves in context, such as whether it applies to selected audio, whether it can be undone, or what the tool returns.

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

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

The schema has zero descriptions for its parameters, so the Args block is the only source of semantic meaning. It fully documents all three parameters with dB ranges, defaults, and clarifies that gain is output gain, which is valuable 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 first sentence, 'Adjust bass and treble frequencies with a simple tonal shaping tool,' clearly names the action and target. It is distinguishable from more complex siblings like effect_equalization by the word 'simple', though it does not explicitly name the alternative it competes with.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when-to-use or when-not-to-use guidance. The phrase 'simple tonal shaping tool' weakly implies it is for basic bass/treble adjustments rather than full equalization, but no alternative is named and no exclusion criteria are provided.

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

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

With no annotations, the description carries the burden and does convey useful behavior: it targets 'selected audio' and guarantees tempo preservation, and explains semitone sign. However, it omits whether the effect is destructive/undoable or whether a selection is strictly required.

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

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

Two concise sentences plus a clean Args block. No filler, and the core purpose 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 one-parameter effect tool, it explains the action, the parameter, and the scope ('selected audio'). It lacks notes on prerequisites or return behavior, but no output schema is expected and the calling contract is otherwise 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?

Schema description coverage is 0%, but the description fully compensates by giving units ('semitones'), sign semantics ('negative = lower, positive = higher'), and hence the meaning of the default 0. This adds real value beyond the bare schema title.

Input schemas describe structure but not intent. Descriptions should explain 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 the pitch of the selected audio' and adds the distinguishing constraint 'without changing tempo.' This clearly separates it from siblings like effect_change_tempo and effect_change_speed.

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

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

'Without changing tempo' gives clear context for when to choose this tool over tempo/speed alternatives, even though no sibling name is explicitly mentioned and there is no when-not-to-use statement.

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

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

With no annotations, the description carries the behavioral burden. It usefully discloses that speed changes tempo and pitch together and provides the percent range and example, but it does not state whether the operation is destructive, requires a selection, or is undoable, leaving some behavioral gaps.

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

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

The description is compact and front-loaded: the core behavior is stated in the first sentence, and the parameter explanation is minimal but complete. 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 one-parameter effect tool this is nearly complete, but it lacks usage differentiation from closely related siblings and any safety/undo guidance despite having no annotations. The core information needed to invoke the tool is present, though.

Complex tools with many parameters or behaviors need more documentation. 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% parameter description coverage, so the 'Args: percent' section is essential. It provides the valid range (-99 to 4900) and a concrete example (100 = double speed), fully clarifying the parameter's meaning beyond the bare schema definition.

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

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

The opening clause names a specific action and resource — change speed of selected audio — and explicitly clarifies that both tempo and pitch change together, which distinguishes it from sibling tools like effect_change_pitch and effect_change_tempo.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 prefer this tool over effect_change_tempo or effect_change_pitch, nor when not to use it. The phrase 'selected audio' implies a precondition, but there is no explicit when/when-not or alternative-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 full burden. It discloses that pitch is preserved (a key behavioral trait) and gives percent range semantics. However, it doesn't disclose that altering tempo changes the duration of audio, whether the operation is destructive to the original clip, whether it affects clip boundaries or waveform data, or how it handles selections vs. whole clips. For an effect that modifies audio, this is a significant transparency gap.

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

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

The description is compact: one title line plus one parameter explanation. The key behavioral point (without changing pitch) is front-loaded in the first sentence. The Args section is terse and useful. Minor credit loss because the title/tool name and description overlap, and 'without changing pitch' is the only behavioral context beyond the parameter spec.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 effect tool, the description handles the parameter semantics well and states the core behavior. But it lacks any context about what the operation does to the audio file (duration change, destructuring), what the user should expect, or how to undo/revert. Given there's no output schema and no annotations, an agent has to infer side effects. The presence of sibling effect_change_speed and effect_change_pitch suggests this tool needs more differentiation to be 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 has only one param 'percent' with default 0 and 0% coverage, so description must compensate. It does: explains percent is a percentage change, gives a valid range (-95 to 3000), and provides concrete examples for both positive and negative values. This adds substantial meaning beyond the bare schema. It doesn't clarify whether 0 means no change or is invalid, but the range and examples largely compensate for the schema 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 changes tempo of selected audio while preserving pitch, using a specific verb ('Change') and resource ('tempo of the selected audio'). It is well-differentiated from siblings like effect_change_pitch and effect_change_speed by explicitly noting pitch is preserved. However, it doesn't explicitly contrast with effect_change_speed, which also changes tempo-like timing, so a very minor distinction gap exists.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 on selected audio ('Change the tempo of the selected audio'), so an agent knows selection is a prerequisite. It provides percent semantics with examples, but doesn't explicitly state when to prefer this over effect_change_speed or effect_change_pitch, nor does it describe what qualifies as selected audio or how selection is made. The implied usage is adequate but not explicit.

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

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

With no annotations, the description must carry behavioral transparency itself. It discloses the operation and reconstruction approach, but does not state that the effect modifies the selected audio in place, whether it is destructive, or how it handles borderline clipping. The word 'Attempt' does signal heuristic behavior, but key application context is missing.

Agents need to know what a tool does to the 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 tightly scoped parts: a one-sentence purpose followed by an Args block. No filler or repeated schema information, and the main 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 one-parameter effect with no output schema, the description is mostly sufficient to call it; threshold semantics are fully specified. The main missing piece is the application context (selected audio) and a hint to detect clipping first, which would help an autonomous agent sequence it.

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

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

The description adds real meaning to threshold: it defines it as a percentage of max amplitude, gives a 0-100 range, and restates the default. The schema only provides a type and default, so this is a substantial addition.

Input schemas describe structure but not intent. Descriptions should explain 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 ('repair'), names the target resource ('clipped audio'), and explains the method ('reconstructing peaks'). This clearly differentiates it from generic siblings like effect_repair.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 apply this tool versus alternatives such as effect_repair or analyze_find_clipping. The context of an active selection or prerequisite is not mentioned, so an agent must infer usage from the name.

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

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

With no annotations, the description carries the burden of explaining behavior. It clearly states the state-dependent requirement (selecting the junction point) and the scope (same track, adjacent clips), but it does not disclose reversibility, failure conditions, or what happens to the clips beyond the crossfade.

Agents need to know what a tool does to the 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, no filler, and the most essential information is front-loaded: the action in the first sentence and the prerequisite in the second. Every word contributes.

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

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

For a parameterless, output-schema-less effect command, the description provides the action, object constraints, and required selection state. It lacks only a brief note on selection validity or failure behavior, which keeps it from being 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?

There are zero input-schema parameters, and the description compensates by documenting the real implicit input: the selected junction point between two adjacent clips. This is exactly the semantically important state an agent needs to invoke the tool 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 specifies the exact verb ('Crossfade'), the resource ('clips'), and the constraints ('adjacent clips on the same track'). This clearly distinguishes it from siblings like effect_crossfade_tracks or individual fade effects.

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

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

It communicates when the tool is applicable: only for two adjacent clips on the same track, and provides a concrete precondition ('Select the junction point between two clips first'). It does not explicitly name alternative tools or exclusions, 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 carries the full behavioral burden. It does disclose prerequisites (overlap and selection) and the nature of the operation (crossfade). However, it does not state whether the effect modifies the original tracks destructively, whether it is undoable, or what happens to the selection afterward. The steps add useful behavioral context but leave the safety/impact profile unclear, which is typical for an effect tool without annotations.

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

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

The description is two concise sentences with no filler. The purpose is front-loaded, followed by actionable steps. Every word contributes meaning, making it highly 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?

Given that the tool has no parameters, no output schema, and minimal complexity, the description covers the essential invocation details: what it does and how to prepare for it. It could optionally mention the relationship to effect_crossfade_clips or clarify that the crossfade replaces the overlapping section, but these are minor omissions. The description is adequately complete for an agent to call 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 tool has zero parameters, and the schema is already fully covered (100% coverage with an empty properties object). Per the rubric, a tool with no parameters gets a baseline of 4. The description adds no parameter-specific detail because none exists, which is appropriate; the baseline holds.

Input schemas describe structure but not intent. Descriptions should explain 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 (crossfade) and the resource (two overlapping tracks), with a specific verb-noun pairing. It naturally distinguishes itself from the sibling effect_crossfade_clips by specifying 'tracks' rather than clips, so an agent can tell them apart without inspecting schemas.

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

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

The description provides clear usage steps: align tracks to overlap, select both, then run. This establishes the precondition and the exact invocation sequence, but does not explicitly mention exclusions or alternatives (e.g., when not to use, or that effect_crossfade_clips exists). Since it gives clear context without exclusion, it earns a 4, not a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says it applies a distortion effect. It does not explain whether the operation modifies audio destructively, requires a selection, affects the whole project, or can be undone.

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

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

The description is short and front-loaded with the main action, followed by a compact parameter list. It repeats defaults already present in the schema, but overall it contains no 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 tool with no annotations and no output schema, the description is too sparse to fully support correct invocation. It omits accepted distortion_type values, does not clarify selection prerequisites, and provides no behavioral or return information.

Complex tools with many parameters or behaviors need more documentation. 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 parameter documentation in the description matters. It usefully adds the dB range for threshold_db and restates defaults, but distortion_type is only described as 'Type of distortion' with no accepted values beyond the default, leaving a meaningful 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 opens with a clear action and resource: 'Apply distortion effect to the selected audio.' This identifies the tool's function precisely and distinguishes it from effect_amplify, effect_reverb, and other effect siblings by name. It is clear but does not explicitly contrast itself with sibling effects.

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

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

The phrase 'to the selected audio' implies that the tool should be used when a distortion effect is desired on an active audio selection. However, there is no explicit guidance about when not to use it, what alternatives exist, or what prerequisites 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, the description must carry the full behavioral burden. It states that the effect is applied to selected audio, but it does not disclose whether the operation is destructive/undoable, whether a selection is required, or what happens if no audio is selected. These are important side effects for a mutation-style audio 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 extremely concise and front-loaded with the purpose. The parameter documentation is compact and directly useful, with no filler or redundant content.

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

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

For a simple two-parameter effect tool, the core invocation details are present: what it does and what the parameters mean. However, with no annotations and no output schema, it should also mention whether the modification is in-place/destructive and whether an audio selection is required. These are 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?

The description fully compensates for the 0% schema description coverage. It explains that 'delay' is in seconds and gives a default, and it defines 'decay' as a 0-1 factor with the interpretation 'lower = faster decay'. This adds meaningful semantics 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?

The description states a specific action ('Apply echo effect') and target ('selected audio'), clearly identifying the tool's function. It is distinct from obvious siblings like effect_reverb by naming 'echo', but it does not explicitly differentiate itself from related effects such as echo/reverb/repeat.

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

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

The description gives no guidance about when to use this tool versus alternatives like effect_reverb or effect_repeat. It implies use when an echo effect is needed, but it does not state any exclusions, prerequisites, or preferred contexts.

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

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

With no annotations, the description carries full burden of behavioral disclosure. It only says 'apply EQ curve' – a mutation – but doesn't mention whether it's destructive, whether a selection is required, whether it affects the entire clip, or describe any side effects. This is a significant omission for a processing 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 very brief, but the brevity comes from under-specification rather than efficiency. It front-loads the purpose but repeats parameter defaults that are already in the schema, and lacks substance. No unnecessary verbosity, but also no valuable 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 fails to cover important context: what happens if no audio is selected, what curve presets are available, how the filter length affects sound, and whether the operation is undoable. An agent would have to guess before invoking it.

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

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

Schema coverage is 0%, but the description adds meaning for both parameters: length is specified as an odd number in range 21–8191, and curve_name is identified as a preset name. However, it doesn't list valid curve names or explain how length affects the result. Partial compensation but not complete.

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

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

The description states a clear action ('Apply') and target ('EQ curve' to selected audio). It distinguishes from other effects like high-pass/low-pass filters by naming 'EQ curve' specifically, though it doesn't explicitly contrast with sibling tools like raw_graphic_eq.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 vs alternatives. It doesn't mention any context, prerequisites, or that it should be used instead of other EQ-related tools. The description is entirely silent on usage 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 must carry behavioral disclosure. It communicates that the tool mutates audio by applying a fade-in and requires a selection, but it does not mention reversibility, whether the original audio is replaced, or any default fade behavior. These gaps are modest for a well-known effect.

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

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

Two short sentences, each earning its place: one states the operation, the other states the required precondition. No redundant wording or unnecessary detail.

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

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

For a parameterless audio effect with no output schema, this is complete. It explains what happens, what scope is affected, and what must be done first. There is no missing information an agent needs to invoke it correctly.

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

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

The tool takes zero parameters, so the description does not need to document anything beyond the operation itself. The baseline of 4 applies here since there are no parameters whose meaning could be clarified.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Apply a fade-in') and resource ('selected audio'), making the tool's purpose unmistakable. It also distinguishes this from related effect tools by naming the exact operation rather than a generic 'apply effect' phrase.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 operational context: the user must select the audio region before invoking the tool. It does not explicitly name alternatives like effect_fade_out or effect_adjustable_fade, but the prerequisite is enough to tell the agent 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that the tool applies a fade-out and requires a selection, but it does not mention whether the operation is destructive, reversible, or what actually happens to the audio beyond 'fade-out.' For a mutation tool, this leaves important behavior undisclosed.

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

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

Two short sentences: one states the action, one states the required precondition. There is no filler, and the essential usage requirement is included.

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

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

For a zero-parameter tool with no output schema, the description is mostly complete: it says what the tool does and what must be done first. It lacks explicit safety or reversibility guidance, but the operation is simple enough that this is a minor gap.

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

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

This tool has no parameters, so there is nothing for the schema to document. The description appropriately refers to the selection prerequisite instead, which is the meaningful input the agent needs to understand.

Input schemas describe structure but not intent. Descriptions should explain 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 and resource: 'Apply a fade-out to the selected audio.' It distinguishes the tool from fade-in by direction, though it does not explicitly differentiate it from similar sibling tools like effect_studio_fade_out or effect_adjustable_fade.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an explicit prerequisite: 'Select the region to fade first.' This gives usable context for when to use the tool, but it does not mention alternatives, when not to use it, or how it compares to other fade-related tools.

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

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

No annotations are provided, so the description carries full burden. It states the core effect (removes low frequencies) and parameter defaults, but does not mention whether it applies to the current selection, if it is destructive/irreversible, or any side effects. The description adds some behavioral context but lacks explicit statements about the operation's scope and reversibility.

Agents need to know what a tool does to the 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, with a short purpose statement, a usage hint, and a clearly formatted args list. Every sentence serves a purpose, and the most important information (function) is front-loaded. No 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 tool with 2 parameters and no output schema, the description provides enough to select and invoke it correctly: it explains the effect, the usage context, and each parameter with defaults. The only missing piece is an explicit statement about the audio selection scope (e.g., applies to selected audio), which is likely implied by it being an effect. Overall, it's complete enough for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does: frequency is in Hz with a default of 40 and explains its purpose (sub-bass rumble removal); rolloff options are enumerated ('dB6' and 'dB12') with meaning (6 dB/octave vs 12 dB/octave). This adds substantial 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?

The description states a specific action (apply) on a specific resource (high-pass filter) and explains its function (removing low frequencies below a cutoff). It clearly distinguishes from the sibling low-pass filter by mentioning 'high-pass' and the direction of frequency removal. Explicit 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 gives explicit context: 'Essential as step 1 in mastering chains to remove sub-rumble.' This tells the agent when to use it (mastering, sub-rumble removal). It does not mention alternatives or when not to use, but the guidance is clear enough for selection among effects.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the transformation (phase inversion) but does not disclose whether the operation is destructive, whether the selected audio is replaced, whether undo is available, or what the success/return behavior is. For a mutation tool, this is a meaningful 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?

Two short sentences with no filler. The operation is front-loaded in the first sentence, and the practical use case is added in the second. Every word earns its place.

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

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

For a zero-parameter effect tool, the description is mostly complete: it says what the tool does and when it is useful. The main gap is the lack of any mention of result or side-effect behavior, which is more noticeable because there is no output schema to fill that in.

Complex tools with many parameters or behaviors need more documentation. 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 implicitly identifies the operand as 'the selected audio,' which is the only contextual detail needed. No parameter documentation is required beyond this.

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

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

The description uses a specific verb and resource: 'Invert (flip phase) the selected audio.' The parenthetical 'flip phase' disambiguates from sibling tools like effect_reverse, which reverses time rather than polarity. It clearly identifies the operation and object.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 use context: 'Useful for phase cancellation.' This implies when an agent should consider using the tool, though it does not explicitly mention alternatives or when not to use it. There is enough context to route correctly among the many effect siblings.

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

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

The description gives basic function but omits key behavioral details: it does not mention whether the effect modifies the selected audio destructively, whether it applies to the current selection or entire track, or any side effects. With no annotations, these missing details leave the agent uncertain about the operation's impact.

Agents need to know what a tool does to the 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 succinct and well-structured, with a single purpose sentence followed by clear parameter explanations and defaults. No unnecessary words 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 covers the core function and parameters, but lacks context about the scope of the effect (e.g., applies to selected audio) and does not mention any output or return value. For a simple filter this is adequate, but an agent might need to infer how it integrates with the editing workflow.

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

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

The description explains both parameters: frequency is the cutoff in Hz, and rolloff is the steepness with specified allowed values, including defaults. This adds meaning beyond the bare parameter names, though it does not elaborate on how these values affect sound quality or the filter's response.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Apply') and resource ('low-pass filter'), and the purpose is unambiguous: it removes high frequencies above a cutoff. This distinguishes it from other effects like high-pass filters.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., when a low-pass filter is preferred over high-pass or equalization). The description merely states what it does without indicating typical use cases or scenarios where it should be avoided.

Agents often have multiple tools that could apply. Explicit usage 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 convey behavior. It explains parameters and defaults but does not mention whether the effect is destructive, applies to selection only, or whether it's undoable. Significant gaps for a mutation tool.

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

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

Two concise sentences that front-load the purpose and then detail parameters with defaults. 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?

Does not mention selection context (e.g., applies to selected audio) or any output, but for a simple effect this may be implicitly understood. Lacks a bit of practical workflow 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?

The description explains both parameters beyond the schema: frequency is the center frequency, q is sharpness with a note that higher values give narrower notches. This adds meaningful context and covers the entire parameter set.

Input schemas describe structure but not intent. Descriptions should explain 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 verb 'Remove' and the resource 'specific frequency' using a notch filter, with a concrete example (50/60Hz hum). This distinguishes it from other effects like equalization or high-pass filters.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 (removing mains hum) which implies when to use, but does not explicitly mention alternatives or when not to use, leaving some ambiguity relative to sibling effects.

Agents often have multiple tools that could apply. Explicit usage 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 disclose whether the effect is destructive, reversible, or how it modifies the audio beyond stretching. It lacks details about side effects, output behavior, or safety, which is a significant gap for an audio processing 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 concise, using a clear header and a parameter list. It provides essential information without unnecessary verbosity, making it easy to parse and understand.

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

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

It includes the prerequisite of selecting audio, but does not specify the scope (e.g., selection vs. whole track), output behavior, or how it interacts with the project. Lacks details on whether the processing is reversible or if there are any side effects on surrounding audio.

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

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

Both parameters are well explained: stretch_factor is described as the amount of stretch with a default of 10, and time_resolution is explained as affecting quality and speed, with a default. This adds meaningful context beyond the schema's title and default 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 it is an 'extreme time-stretch effect' that 'creates ambient/drone textures,' which is a specific and distinctive function. It is distinct from other effects like change_tempo or change_speed, making the purpose unambiguous.

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

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

It provides a prerequisite ('Select audio first') and parameter explanations, but does not explicitly contrast with alternative effects. There is no guidance on when to prefer this over other time-stretching or modulation effects, leaving some ambiguity in tool selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It documents parameter defaults and ranges but does not state that applying the effect modifies the selected audio in place, whether the operation is destructive/undoable, or any processing side effects. 'Apply ... to the selected audio' only weakly implies the behavioral impact.

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

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

Front-loaded one-sentence purpose followed by a clean, aligned argument list. Each line carries unique semantic information (range, unit, constraint, default) with no filler. The list is lengthy but justified by the six-parameter signature.

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