ihateaudio

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

The description adds substantial behavioral context beyond annotations: it explains the server downloads the file from download_url, that the result links expire after 1 hour, the storage/processing architecture (Cloudflare R2, headless browser), and that the input is deleted when the job ends. Annotations already declare it's not readOnly, not idempotent, not destructive. The description covers important lifecycle details (input deletion, link expiry) that annotations don't.

Agents need to know what a tool does to the 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: effect description, input requirements, optional settings, output info, and processing details. Front-loaded with the core effect. Slightly long 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 complex audio processing tool with nested object parameters and no output schema. Covers input constraints, optional settings, output format, link expiry, storage, and deletion. Could better explain the settings object structure.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by naming specific settings for set_8d_effect (secondsPerTurn, distance) and explaining outputFormat/bitrateKbps usage, but does not provide format syntax or defaults beyond what schema offers. Slightly better than baseline due to naming the settings object contents.

Input schemas describe structure but not intent. Descriptions should explain 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 effect ('Pans the audio in a circle around the listener - the 8D audio effect') which is a distinct audio processing operation. Given the long list of siblings, it's clear this is a specialized panning effect tool, distinguishable from things like stereo_widener or reverb_adder.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 context ('one file with a public HTTPS download_url') but does not explicitly state when to use this vs alternatives like stereo_widener or reverb_adder. No exclusions or alternatives are mentioned.

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

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

Beyond the annotations (readOnlyHint=false, non-idempotent, non-destructive), the description discloses genuinely useful behavior: the server downloads the URL, stores it in Cloudflare R2 during the job, processes via a headless browser, and deletes the input when the job ends. The 1-hour expiry on result links is a critical operational detail not captured anywhere in the schema.

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

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

Purpose and input are front-loaded, and the lifecycle/expiry sentences earn their place. The backend implementation detail (headless browser, Cloudflare R2) is somewhat beyond what an agent needs to invoke the tool correctly, but the description stays readable in one paragraph.

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

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

With no output schema, the description correctly explains that it returns download links that expire after 1 hour, and it covers input requirements and job lifecycle. It is nearly complete, with only the missing explicit sibling routing keeping it from 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?

Schema description coverage is 100%, so the parameters are already documented, making 3 the baseline. The description restates outputFormat examples already present in the schema and adds only the soft qualifier "where the tool supports them" for outputFormat/bitrateKbps, which is marginal added meaning.

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

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

The description gives a specific verb and resource ("Isolates the vocals from a song by source separation and returns the vocal track"), which is clearly distinct in meaning from a stem splitter or converter. However, it never names the obvious sibling (vocal_remover) whose function is the inverse, leaving that routing to inference. Clear purpose, but no explicit sibling differentiation.

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

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

It states input constraints (one file, public HTTPS download_url), which implies usage but never says when to pick this tool over vocal_remover (which keeps the instrumental) or stem_splitter (all stems). No exclusions or alternative routing are given, so the agent must infer the choice.

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

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

Beyond the annotations (which only give the generic safety profile), the description discloses real behavioral traits: download links expire after 1 hour, the file is stored in Cloudflare R2 during the job, processing happens in a headless browser, and the input is deleted when the job ends. That is meaningful data-handling and lifecycle context, though async/polling behavior and rate limits are not addressed.

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

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

Purpose is front-loaded in the first clause, followed by input requirements and options in a logical order. The server/R2/headless-browser sentence is long and slightly dense but carries genuine information, so little is wasted.

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

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

With no output schema, the description usefully explains what is returned (download links with a 1-hour expiry) and covers input, optional settings, and output formats. It is nearly complete for the call, missing only explicit async/status behavior.

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

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

Schema coverage is 100%, so the schema already documents files, settings, outputFormat, and bitrateKbps. The description mainly restates the settings keys and format examples already present in the schema, adding only the 'set_ringtone' framing, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Cuts a section of a song into an MP3 ringtone for Android'), so the agent knows exactly what the tool produces. The 'for Android' qualifier partly distinguishes it from the sibling ringtone_maker, but the description never explicitly contrasts the two, so differentiation is incomplete.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 concrete input prerequisite ('one file with a public HTTPS download_url'), which implies when the tool is applicable, but there is no explicit when-to-use vs when-not guidance and no routing to the sibling ringtone_maker or audio_trimmer. Usage is therefore inferable but 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?

Annotations only cover the generic safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), while the description adds substantial non-obvious behaviour: output download links expire after 1 hour, the server fetches the file from download_url, stores it in Cloudflare R2 during the job, processes it in a headless browser, and deletes the input when the job ends. These lifecycle and storage facts are exactly the context an agent cannot get from structured fields. No contradiction with annotations.

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

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

Purpose and input requirements are front-loaded, and the sentences on link expiry and input deletion clearly earn their place. The infrastructure sentence about R2 storage and a headless browser on Cloudflare is less decision-relevant but does not bloat the text excessively.

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

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

With no output schema, the description correctly fills the gap by explaining the return value (download links that expire after 1 hour) and the input contract (public HTTPS download_url). It is nearly complete, though it does not clarify behaviour when multiple files are supplied despite the schema allowing up to 12 items.

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

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

Schema description coverage is 100%, so the schema already documents files, settings, bitrateKbps and outputFormat. The description largely repeats this (settings keys, outputFormat examples) but does add one useful qualifier — that outputFormat and bitrateKbps apply 'where the tool supports them' — so it sits at the baseline rather than below it.

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

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

The description states a specific verb and resource ('Makes an audio file smaller') and names the mechanism (lowering bitrate, sample rate or channel count), which usefully distinguishes it from dynamic_compressor and the various *_converter siblings. It never explicitly names or excludes a sibling, so it stops just short of a 5.

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

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

Usage is implied by the purpose statement: reach for this when you want a smaller audio file via reduced bitrate/sample rate/channels. However, there is no explicit when-to-use guidance and no routing advice versus near-neighbours like audio_converter, sample_rate_converter or stereo_to_mono, leaving selection 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?

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the bar is lower, yet the description still adds real value: result links expire after 1 hour, the file is fetched server-side into Cloudflare R2 for the duration of the job, and the input copy is deleted when the job ends. It does not state auth requirements, but the data-lifecycle and expiry details are substantive. Minor tension with openWorldHint=false given the public-URL fetch, though not a direct contradiction.

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

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

Front-loads the conversion capability and input shape, then appends return/lifecycle details. Sentences are dense and mostly earn their place, though the Cloudflare/headless-browser implementation sentence is closer to trivia than decision-relevant information.

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

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

No output schema exists, so the description must cover returns — it does ('Returns download links for the result, which expire after 1 hour'). Input format, optional params, and data retention are all addressed. Only the sibling-routing question and auth needs remain unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents files, bitrateKbps and outputFormat, establishing a baseline of 3. The description restates outputFormat examples and notes bitrate applies 'where the tool supports them' (i.e. lossy formats), but adds no syntax or constraint details beyond what the schema provides.

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

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

States a specific verb and resource ('Converts audio between MP3, WAV, M4A, OGG, FLAC and other formats'), and the 'other formats' phrasing hints at a general-purpose converter. However, it never distinguishes itself from the numerous format-specific siblings (mp3_converter, wav_converter, flac_converter, m4a_converter, ogg_converter), leaving the agent to guess which to pick.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 notes the input requirement (one file with a public HTTPS download_url) but gives no when-to-use guidance, no exclusions, and no routing to alternatives. With ~8 sibling conversion tools, the absence of any selection criteria is a clear gap.

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

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

Adds substantial context beyond the annotations: output links expire after 1 hour, the server downloads from download_url and stages it in R2 for the job duration, processing runs in a headless browser, and the input is deleted when the job ends. This gives the agent a full picture of lifecycle, retention and latency behavior.

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

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

Front-loads the purpose in the first clause, then layers input requirements, options, return behavior and infrastructure notes. Sentences are information-dense and mostly earn their place, though the Cloudflare/headless-browser detail is longer than an agent strictly needs.

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

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

For a 4-parameter tool with a nested generic settings object and no output schema, the description covers input shape, ordering, options, return format and expiry, and processing side effects. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value: it clarifies that the generic `settings` object carries `gapSec` for set_join_gap, that file order is meaningful, and that outputFormat/bitrateKbps apply 'where the tool supports them'. It notes 'two or more files' although the schema allows minItems 1, a minor discrepancy.

Input schemas describe structure but not intent. Descriptions should explain 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 (joins) and resource (several audio files) plus the key constraint that order matters and a gap is optional. It clearly reads as a concatenation tool, but it never distinguishes itself from the closest sibling, crossfade_joiner, so an agent must infer the boundary between the two.

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

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

Gives operational prerequisites (two or more files, each with a public HTTPS download_url, in processing order) which implies the use context, but offers no explicit when-to-use, when-not-to-use, or alternative routing such as crossfade_joiner for overlapping transitions.

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

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

Goes well beyond the annotations by disclosing the full job lifecycle: the server downloads the file, stores it in Cloudflare R2 while the job runs, processes it in a headless browser, and deletes the input when the job ends. It also states that returned download links expire after 1 hour, which an agent must know. This is rich context for a non-read-only job tool.

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

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

Front-loads the core operation in the first sentence, then covers input, settings, output, and lifecycle. Efficient overall, though the R2/headless-browser infrastructure sentence is heavier than strictly necessary for tool selection.

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

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

With no output schema, the description correctly explains the return value (expiring download links) and covers input constraints, settings, and data handling. Minor gap: repeats/gapSec are named but their units/ranges are left implicit (gapSec implies seconds, repeats bounds unspecified).

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

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

Schema coverage is 100%, so baseline is 3, but the description adds meaning the schema lacks: it names the specific settings keys ('repeats, gapSec') even though the schema only declares settings as additionalProperties with a generic propertyNames, and it gives outputFormat examples plus a 'where the tool supports them' caveat for bitrateKbps.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Repeats a clip a set number of times, with an optional gap'), which is a unique operation not duplicated by any sibling. It does not explicitly differentiate itself from near-neighbors like audio_joiner or crossfade_joiner, so it falls just short of 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?

Usage is implied by the operation (loop a clip) and it states a real prerequisite ('one file with a public HTTPS download_url'), but there is no explicit when-to-use/when-not guidance and no alternative tool named despite a large 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?

With annotations only covering the generic safety flags, the description adds substantial behavioral detail: the server fetches from download_url, holds the intermediate in Cloudflare R2, processes via a headless browser, deletes the input when the job ends, and returns download links that expire after one hour. It also notes outputFormat/bitrateKbps are only honored 'where the tool supports them.'

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

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

Front-loaded with purpose, target examples, and the input contract, then lifecycle and return behavior. The infrastructure sentence (R2/Cloudflare headless browser) is the one stretch of implementation detail, but it still conveys relevant processing context.

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

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

For a mutation tool with no output schema and a passthrough settings object, the description covers everything an agent needs: required input shape, target semantics, format options, the 1-hour link expiry, and the fact that the source file is not retained. Nothing material is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description restates the settings keys (platform, targetLufs, ceilingDbtp) that the schema already lists and adds little syntax or valid-range detail; its only genuine addition is the caveat that bitrateKbps applies only to supported formats.

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

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

The description gives a specific verb+resource ('Normalizes loudness to a LUFS target') with concrete target examples (-14 Spotify, -16 podcasts) and a true-peak ceiling, making it clearly distinct from the neighboring loudness_meter and volume_booster. It never names a sibling explicitly, so it stops short of full differentiation.

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

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

Platform-target examples imply the use case (streaming/podcast loudness compliance), but there is no explicit 'use this when...' guidance and no mention of when to prefer loudness_meter or volume_booster instead. Usage is inferable rather than stated.

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

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

Annotations already flag non-readonly, non-idempotent behavior, but the description adds substantial operational context: server-side download, temporary R2 storage during the job, headless-browser processing, deletion of the input at job end, and 1-hour expiry of result links.

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

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

Front-loads the core purpose, then covers input, optional options, output lifetime, and backend handling. The backend storage/processing details are longer than typical but relevant for trust and privacy; no sentence feels purely wasteful.

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

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

No output schema exists, and the description explains the return (download links expiring after 1 hour). For a non-idempotent processing tool, it discloses input handling, storage, deletion, and output lifetime, leaving no critical gap 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?

Schema description coverage is 100%, so parameters are already well documented. The description restates the required file/download_url and optional outputFormat/bitrateKbps, adding only the caveat that formats/bitrates are supported 'where the tool supports them' without enumerating supported values.

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

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

States the specific transformation ('Reverses audio so it plays from end to start') with a clear verb and resource. In a large sibling set of audio processors, this unique effect is immediately distinguishable from alternatives.

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

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

Specifies the input prerequisite (one file with a public HTTPS download_url) and optional parameters, giving clear context for invocation. It does not name alternative siblings or state when not to use this tool, but the transformation is distinct enough that exclusions are less critical.

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

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

Goes well beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false) by disclosing the full data path: server downloads from download_url, stores in Cloudflare R2 during the job, processes via a headless browser, deletes the input when the job ends, and returns download links that expire after 1 hour. These retention, storage, and expiry facts are exactly the context an agent needs and cannot get from the schema.

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

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

Front-loaded: the first two sentences carry the core purpose and inputs, followed by output and infrastructure details. The Cloudflare/R2/headless-browser sentence is long but earns its place as behavioral disclosure rather than 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 complex tool with a nested `files` array, an open-ended `settings` object, and no output schema, the description covers input constraints, the settings surface, return-value form and expiry, and the data-retention lifecycle. Nothing essential for correct invocation is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does name the settings keys (method, parts, partLengthSec, silenceThresholdDbfs, minimumGapSec), but the schema's `settings` description already lists the same names, and the description adds no units, ranges, or valid values (e.g., dBFS thresholds or acceptable part counts). 'where the tool supports them' is vague for outputFormat/bitrateKbps.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Splits a recording into parts') and enumerates the three splitting modes (set number, set length, at silences), which is enough to distinguish it from nearby tools like audio_trimmer or silence_remover. It never names a sibling explicitly, so it falls short of the top score.

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

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

The description states a prerequisite ('one file with a public HTTPS download_url') and lists optional settings, but gives no explicit when-to-use vs. when-not-to-use guidance or alternative tools. Usage is implied rather than directed.

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

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

Annotations are minimal (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the description carries the burden and does so well: it discloses storage in Cloudflare R2, headless-browser processing, that the input is deleted when the job ends, and that output download links expire after 1 hour. These are non-obvious lifecycle behaviors an agent needs.

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

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

Purpose is front-loaded in the first sentence, followed by parameter notes and then the storage/lifecycle details. It is somewhat dense with infrastructure detail, but each sentence conveys actionable information rather than 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 processing tool with nested input objects and no output schema, the description covers input requirements, output-link expiration, and job lifecycle well. Minor gap: it frames input as 'one file' while the schema allows up to 12 items, leaving the multi-file case slightly ambiguous.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning: it clarifies outputFormat examples, that bitrateKbps applies only 'where the tool supports them', and ties settings to a 'set_transcript_layout: paragraphs' option. This goes beyond restating the schema fields.

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

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

States a specific verb and resource ('Transcribes the speech in a recording to text') and names the underlying technology (Whisper). This clearly separates it from siblings like subtitle_generator or waveform_generator, though it does not explicitly name an alternative it is not.

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

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

There is no explicit when-to-use, when-not-to-use, or sibling routing guidance. An agent must infer from the purpose that this is the transcription tool versus e.g. subtitle_generator, with no stated conditions or prerequisites for choosing it.

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

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

Annotations already mark this as a non-readonly, non-destructive, non-idempotent operation, and the description adds a lot beyond that: result links expire after 1 hour, the file is downloaded from download_url, held in R2 during the job, processed via a headless browser, and the input copy is deleted at job end. It doesn't cover auth, quotas, or failure behavior, which keeps it from a 5.

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

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

The primary behavior is front-loaded in the first sentence, followed by input requirements, optional settings, return behavior, and pipeline details. Every sentence carries information, though the R2/headless-browser processing chain is longer than most callers need.

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

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

With no output schema, the description correctly explains that download links are returned and expire in an hour, and it documents the full input lifecycle. The remaining gap is the free-form settings object, whose mode and fade semantics are named but never defined in either schema or 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?

Schema description coverage is 100%, so the baseline is 3. The description echoes the schema's settings fields (startSec, endSec, mode, fade) and adds only a minor qualifier that outputFormat/bitrateKbps apply 'where the tool supports them'; it supplies no units, ranges, or allowed mode values for the free-form settings object.

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

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

The description names a specific verb and resource and scope: 'Cuts an audio file down to a start and end time, or removes that section,' which cleanly separates it in concept from siblings like fade_in_out, silence_remover, or audio_splitter. It stops short of explicitly routing the agent away from those near-neighbors, which is what a 5 would require.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 states the input precondition ('one file with a public HTTPS download_url'), which is genuinely usable context, but gives no explicit when-to-use/when-not guidance and never names an alternative tool. Usage is inferable from the trim semantics rather than stated.

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

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

Goes well beyond the annotations by disclosing the full lifecycle: the server downloads the file, stages it in Cloudflare R2 for the job duration, processes it via a headless browser, deletes the input when the job ends, and issues download links that expire after 1 hour. This is exactly the kind of operational context annotations do not carry.

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

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

Purpose is front-loaded in the first sentence, followed by input constraints, settings, output, and lifecycle. Most sentences earn their place, though the Cloudflare/headless-browser implementation detail is more verbose than an agent strictly needs.

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

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

For a mutation tool with no output schema, the description supplies the input contract, return artifact (download links), expiry, and cleanup behavior, so an agent has what it needs to call it. The loose 'settings' sub-parameters remain under-specified.

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

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

Schema description coverage is 100%, so the schema already documents files, download_url, bitrateKbps, and outputFormat; the settings object itself is an untyped additionalProperties bag. The description adds only the raw setting names (amountDb, cornerHz, keepLevel) with no ranges, defaults, or meaning, so the baseline 3 is appropriate.

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

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

Names a specific verb and resource ('Boosts the low frequencies'), which is clearly distinct from siblings like volume_booster by targeting the low end specifically. However, it never explicitly contrasts itself with volume_booster or equalizer, leaving the agent to infer the boundary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explains operability (input must be a public HTTPS download_url) but gives no when-to-use guidance and never names alternatives such as volume_booster or equalizer for overlapping requests. An agent must guess which sibling to pick.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, but the description goes well beyond them: it discloses that the server downloads the file, holds it in Cloudflare R2 for the job duration, processes it via a headless browser, returns JSON rather than a file, and deletes the input when the job ends. That data-lifecycle and retention detail is exactly the context an agent cannot get from 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?

Purpose and return type are front-loaded, and the infrastructure sentences are informative. Some implementation trivia (ihateaudio.com tool page, headless browser on Cloudflare) is heavier than the agent needs, but the overall length is justified by the data-handling disclosure.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 nested objects, no output schema, and a vague `settings` object, the description covers input requirements, processing pipeline, retention, and return type well. It stops short of describing the shape of the returned measurement JSON or what `settings` accepts, which would have closed the remaining gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the input shape ('one file with a public HTTPS download_url') and hints that the opaque `settings` object maps to 'set_analysis_range: selectionOnly', but that phrasing is cryptic and adds little actionable meaning for a free-form `additionalProperties: {}` object.

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

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

States a specific verb+resource: 'Measures the tempo of a track in BPM.' The analysis verb cleanly separates it from transformation siblings like tempo_changer, speed_changer, or pitch_shifter, and 'Returns the measurements as JSON, not a file' reinforces that this is a read/measure operation rather than a file producer.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 usage context (a measurement job over one audio file) and specifies input preconditions (public HTTPS download_url), but never states when to prefer this over key_finder, loudness_meter, or tempo_changer, nor any when-not conditions. Usage is inferable but not guided.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the bar is lower, yet the description adds substantial context: download link expiry after 1 hour, server-side download from download_url, transient R2 storage, headless-browser processing, and deletion of inputs when the job ends. These lifecycle facts materially affect how the agent should treat results.

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

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

The purpose is front-loaded in the first sentence, and the expiry/deletion notes earn their place. But the mechanism detail ('processes it with the ihateaudio.com tool page in a headless browser on Cloudflare', 'Cloudflare R2 storage') is infrastructure trivia that does not help tool selection and bloats the definition.

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

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

With no output schema, the description correctly explains return values (download links, 1-hour expiry) and the input constraint that URLs must be public HTTPS. A nested-object tool with a temporary-storage lifecycle is reasonably well covered, though permission/auth needs are unstated.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters and the baseline is 3. The description adds a little meaning by naming fadeSec (the key inside the nested settings object) and giving outputFormat examples, but no format or range details beyond the schema.

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

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

States a specific verb and resource: 'Joins several files with a crossfade between each pair.' The crossfade qualifier functionally distinguishes it from the plain 'audio_joiner' sibling, but the description never names that alternative explicitly, so sibling differentiation is implied rather than stated.

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

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

Provides input requirements (two or more files, in order, each with a public HTTPS download_url), which implies when the tool applies. However it gives no explicit when-to-use guidance versus audio_joiner or fade_in_out, and no exclusions or prerequisites.

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

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

Annotations already cover read-only/idempotency/destructiveness, but the description adds substantial operational context: it downloads from the public URL, stores the file in Cloudflare R2 during the job, processes via a headless browser, deletes the input copy, and returns links that expire after 1 hour. These are exactly the behavioral traits an agent needs beyond the annotations.

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

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

Front-loads the purpose, then covers input, settings, output, and processing. It is somewhat long but well structured; each sentence carries useful information, though the infrastructure detail could be trimmed.

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

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

There is no output schema, and the description explains the return links and their expiry, plus the processing lifecycle. It does not cover error cases or format restrictions, but for a media-processing tool with full parameter schema it is largely complete.

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

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

Schema coverage is 100%, so baseline is 3. The description enumerates the settings keys and gives examples for outputFormat, but adds little beyond the schema; it also says 'one file' while the schema permits up to 12 files, creating minor ambiguity.

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

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

States a specific verb and resource ('applies dynamic range compression') and names the effect ('to even out levels'). However, it does not differentiate from the sibling audio_compressor, so an agent cannot tell from the description alone when to choose this tool over that sibling.

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

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

Provides input requirements and optional settings but no when-to-use guidance or alternatives. It never mentions audio_compressor or any condition under which this tool is preferred.

Agents often have multiple tools that could apply. Explicit usage 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 annotations already covering read/write and destructive hints, the description adds substantial context: download links expire after 1 hour, the input is stored temporarily in Cloudflare R2 during the job, processing happens via a headless browser on ihateaudio.com, and the input is deleted when the job ends. It does not cover auth or rate limits, but it is strong on lifecycle and side effects.

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

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

The description is front-loaded with the core purpose, then input, settings, output, and processing details. It is appropriately sized for a tool with nested parameters and a notable lifecycle, though the Cloudflare/R2 implementation detail is slightly more verbose than strictly necessary.

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

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

There is no output schema, so the description correctly states that the tool returns download links and that they expire after 1 hour. It covers the required input, optional settings, output behavior, and temporary-file lifecycle, though it could mention supported preset values or error behavior.

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

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

Schema description coverage is 100%, so the schema already documents all four top-level parameters and the nested file object. The description repeats the settings keys and gives outputFormat examples, but it adds little semantic detail beyond what the schema already provides; the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Adds an echo or delay effect.' It distinguishes the tool from adjacent siblings like reverb_adder and slowed_reverb, so an agent can tell what effect this applies without opening the schema.

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

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

It explains the required input shape (one file with a public HTTPS download_url) and optional settings, which implies when the tool is applicable. However, it does not explicitly say when to choose this over alternatives such as reverb_adder or slowed_reverb, nor does it state any exclusions.

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

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

Excellent: discloses download of the remote URL, temporary R2 storage, headless-browser processing on Cloudflare, deletion of input when the job ends, and 1-hour expiry of output links. Annotations only cover safety hints, so this descriptive pipeline detail is genuinely valuable.

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

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

Single dense paragraph, front-loaded with purpose, followed by input requirements, options, and infrastructure details. No filler sentences; all content earns its place, though it could be broken up for scannability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 input constraints, optional settings, output link lifetime, and processing/lifecycle behavior. For a 4-param tool with nested files and no output schema, this is largely complete. Could mention input file limits (e.g. max 12, single file) but the schema handles that.

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

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

Schema coverage is 100%, so the schema already documents all four parameters with examples (mp3, wav, m4a) and constraints (exclusiveMinimum, maxItems 12). The description restates outputFormat and bitrateKbps but adds little beyond the schema. Baseline 3 applies.

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

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

States a specific verb and resource: applies an equalizer preset to an input file. Clear what it does. Does not explicitly distinguish from siblings like bass_booster or audio_normalizer, which also shape frequency response, so a small gap remains.

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

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

Implied by 'Applies an equalizer preset' but there is no explicit when-to-use vs alternatives (e.g. bass_booster for low-end emphasis). No prerequisites or exclusions stated.

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

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

Goes well beyond the annotations by disclosing the full data lifecycle: the file is downloaded, held in Cloudflare R2 only while the job runs, processed in a headless browser, and the input copy is deleted at job end. It also states the output download links expire after 1 hour. None of this is derivable from readOnlyHint/destructiveHint/idempotentHint, and nothing contradicts them.

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

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

The core action is front-loaded in the first sentence, followed by input, settings, output, and infrastructure details in a logical order. The infrastructure sentences are somewhat verbose but each carries useful constraint information, so little is wasted.

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

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

With no output schema, the description steps in to describe the return value (download links that expire in 1 hour). Combined with input format requirements, optional settings keys, and output format options, an agent has everything needed to invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it names the nested set_fade keys (fadeInSec, fadeOutSec, curve) that the schema leaves as an untyped additionalProperties object, and qualifies bitrateKbps as applying only 'where the tool supports them,' implying format dependence.

Input schemas describe structure but not intent. Descriptions should explain 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 precise verb and effect: 'Adds a fade-in at the start and a fade-out at the end.' An agent can immediately distinguish this from crossfade_joiner or audio_trimmer. It stops short of naming a sibling to route against, so it is clear but not fully differentiated.

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

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

Usage is only implied by the effect name; there is no explicit when-to-use statement or comparison to alternatives like crossfade_joiner (which blends two files) or silence_remover. The input constraint (one file, public HTTPS download_url) is stated, which gives some practical context, but routing guidance is absent.

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

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

Annotations only declare readOnlyHint=false, idempotentHint=false, destructiveHint=false; the description goes well beyond them by disclosing the return contract (download links expiring after 1 hour), the processing pipeline (server download, Cloudflare R2 retention while the job runs, headless-browser processing), and data lifecycle ('The input is deleted when the job ends'). This is exactly the extra behavioral context annotations cannot carry.

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

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

Front-loaded with purpose, then input, parameters, return contract, and lifecycle, so the agent can stop reading early. Slightly long at six sentences, and the Cloudflare/headless-browser infrastructure detail is more than an agent needs for selection, but nothing is redundant.

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

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

With no output schema, the description correctly explains the return value (expiring download links) and covers input requirements and lifecycle. The only shortfall is the unresolved tension between the 'lossless FLAC' purpose and the lossy outputFormat examples, which could confuse format selection.

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

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

Schema description coverage is 100%, so files/download_url/outputFormat/bitrateKbps are already documented structurally, establishing a baseline of 3. The description restates outputFormat and bitrateKbps with the qualifier 'where the tool supports them', adding only marginal meaning beyond the schema.

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

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

States a specific verb+resource ('Converts audio to lossless FLAC') so an agent immediately knows the operation. However it never distinguishes itself from close siblings like audio_converter, mp3_converter, or wav_converter, and the stated purpose ('lossless FLAC') is muddied by an outputFormat that accepts mp3/m4a/ogg.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 an input precondition ('one file with a public HTTPS download_url'), which implies when it can be used, but offers no explicit when-to-use vs when-not guidance and does not route the agent to the other *_converter siblings for different target formats.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and idempotentHint=false, and the description goes well beyond them: it discloses the download pipeline, temporary retention in Cloudflare R2 during the job, headless-browser processing via the ihateaudio.com tool page, and deletion of the input when the job ends. This is exactly the behavioral context an agent cannot infer from structured fields.

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

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

Four compact sentences, front-loaded with the core purpose before input and pipeline details. Every sentence carries information, though the R2/Cloudflare implementation detail is somewhat heavier than needed for tool selection.

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

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

The description covers purpose, input contract, processing behavior, data retention and the fact that JSON (not a file) is returned, which compensates for the absent output schema. It is slightly incomplete in that it says only 'the measurements' are returned without naming the fields an agent would receive.

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

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

Schema description coverage is 100% for the single nested parameter, so the schema already explains download_url, file_id, file_name and mime_type. The description only restates the HTTPS download_url requirement and adds no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: detecting a track's musical key and Camelot code. The purpose is unambiguous and clearly distinct from siblings like bpm_detector, but it never names or contrasts with any alternative tool, so it stops short of explicit sibling differentiation.

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

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

The description gives an input precondition (one file with a public HTTPS download_url), which implies how and when the tool is usable, but it offers no explicit when-to-use/when-not guidance or routing against the many sibling analysis tools.

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

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

With annotations covering the safety profile, the description adds genuine non-obvious behavior: the server downloads the file from download_url, holds it in Cloudflare R2 during the job, processes via a headless browser, and deletes the input when finished. This data-lifecycle disclosure is valuable and not derivable from annotations or schema. It again omits how long typical jobs run or failure modes, keeping it short of 5.

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

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

Front-loaded with the measurement metrics, then input contract, then return type and backend mechanics. Every sentence carries information, though the Cloudflare/R2/headless-browser detail is slightly verbose for what it contributes to invocation decisions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 read-only measurement tool with full schema coverage and no output schema, the description closes the key gaps: it says it returns JSON measurements rather than a file, specifies the single-file input, and explains the data lifecycle. An agent has everything needed to call it correctly, though expected job duration is unstated.

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

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

Schema description coverage is 100% and the single nested parameter (download_url, plus optional file_id/file_name/mime_type) is fully documented in the schema. The description restates the 'one file / public HTTPS URL' constraint consistent with the schema but adds no new per-parameter meaning, so the baseline 3 applies.

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

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

The description uses a specific verb (measures) plus named metrics (integrated loudness in LUFS, loudness range, true peak) and a standard (ITU-R BS.1770), which no sibling replicates. It is clearly distinguishable from transformation siblings like audio_normalizer or volume_booster because it returns measurements rather than modified 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?

It states the input precondition (one file with a public HTTPS download_url) and that it returns measurements, which implies the analysis use case. However, it never says when to prefer this over alternatives or when it is inappropriate (e.g., for already-uploaded local files vs. URLs), leaving usage to inference.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, idempotentHint=false, and openWorldHint=false. The description adds substantial behavioral context beyond annotations: returned links expire after 1 hour, the server downloads the input, temporarily stores it in Cloudflare R2, processes it in a headless browser, and deletes the input when the job ends.

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

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

The core purpose is front-loaded in the first sentence, followed by input, optional parameters, return behavior, and implementation details. It is mostly efficient, though the Cloudflare R2/headless browser sentence is more implementation detail than invocation guidance.

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

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

There is no output schema, so the description usefully explains that download links are returned and expire after 1 hour. It also covers input handling and deletion. It omits synchronous versus asynchronous behavior and file-size limits, but is otherwise complete enough for invocation.

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

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

Schema description coverage is 100%, so the schema already documents download_url, bitrateKbps, and outputFormat. The description adds minor constraints such as 'one file' and 'where the tool supports them,' but 'one file' conflicts with the schema's maxItems=12, so it does not clearly improve parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain 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: converts audio to M4A (AAC). The target format distinguishes it from sibling converters such as mp3_converter, wav_converter, ogg_converter, and flac_converter. An agent can identify the correct tool without opening any schema.

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

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

The description implies use for M4A conversion and states the required input type, but it does not explicitly say when to choose this over audio_converter or other format converters. No alternatives or exclusions are named, leaving usage routing 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?

Goes well beyond the annotations, which only signal readOnlyHint=false and destructiveHint=false. It discloses that result download links expire after 1 hour, that the server downloads and temporarily stores the file in Cloudflare R2, processes it via a headless browser, and deletes the input when the job ends. This is exactly the lifecycle and auth/URL context an agent needs.

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

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

Front-loads the purpose, then input requirement, optional parameters, return behavior, and backend lifecycle — a logical order. It is somewhat long, with the Cloudflare/headless-browser internals being borderline, but every sentence carries usable 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?

There is no output schema, so the description must cover return values — and it does (download links expiring after 1 hour). Combined with the input requirements and processing/storage/deletion notes, an agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents files, download_url, bitrateKbps and outputFormat. The description restates the inputs and examples ('mp3, wav, m4a') without adding syntax or constraint detail beyond the schema, matching the baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource: 'Converts an audio or video file to MP3.' An agent immediately knows the operation. However, it does not distinguish itself from the numerous sibling converters (audio_converter, wav_converter, m4a_converter, ogg_converter, video_to_audio), and its mention that outputFormat may be 'wav, m4a' actually blurs the boundary further.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 supplies an input prerequisite ('one file with a public HTTPS download_url') but never states when to choose this tool over the near-identical sibling converters, nor any when-not conditions. Usage is only implied by the tool's purpose.

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

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

Goes well beyond the annotations by disclosing that the server downloads the file from download_url, keeps it in Cloudflare R2 during the job, processes via a headless browser, deletes the input when the job ends, and that result links expire after 1 hour. These are exactly the operational traits an agent needs and none are in the structured fields.

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

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

Front-loads the core action and the required input, then layers settings, output, and lifecycle details in a readable order. A few infrastructure clauses (R2, headless browser) are peripheral to invocation but still earn their place as behavioral context.

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

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

With no output schema, the description compensates by explaining the return (download links that expire in 1 hour) and the input lifecycle. It also covers the required public HTTPS download_url constraint, leaving nothing essential for a correct call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description maps 'settings' to set_nightcore's rate/preset and restates outputFormat and bitrateKbps but adds no format, syntax, or range meaning beyond the schema.

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

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

States a specific transformation ('speeds a track up and raises its pitch') and names the domain term 'nightcore', which is precise. Against siblings like speed_changer and pitch_shifter it clearly identifies this as the combined effect, so an agent can route without opening a schema.

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

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

Usage is only implied by the term 'nightcore edit'; there is no explicit when-to-use or when-not guidance. It never tells the agent to prefer this over running speed_changer plus pitch_shifter separately, which is the key sibling decision.

Agents often have multiple tools that could apply. Explicit usage 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 goes well beyond the annotations by disclosing the entire processing pipeline: server downloads the file, stores it in Cloudflare R2 during processing, uses a headless browser, deletes the input when the job ends, and returns download links that expire after 1 hour. This gives the agent valuable context about side effects, temporary storage, and output lifetime.

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

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

The description is front-loaded with purpose and input details, then covers settings, output, and backend behavior. It is well-structured but the backend sentence is long and somewhat verbose; it earns its place for transparency but could be tightened.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 adequately mentions return values (download links expiring after 1 hour). It covers input constraints, optional settings, and processing behavior, making it complete enough for correct invocation. Minor gaps like the maximum number of files (12) are already in the schema.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds a vague mention of 'settings for set_noise_reduction: strength' and examples for outputFormat, but these do not significantly extend the schema's meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific action ('Reduces background noise') and names the targeted noise types (hiss, hum, room noise), clearly distinguishing it from generic audio tools. However, it does not explicitly differentiate from close siblings like silence_remover or vocal_remover, which an agent might confuse without additional guidance.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 input requirements (one file with a public HTTPS download_url) but offers no guidance on when to choose this tool over alternatives or any exclusions. It lacks explicit when-to-use or when-not-to-use instructions.

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

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

Goes well beyond the annotations by disclosing the full lifecycle: server downloads from download_url, holds it in Cloudflare R2 while the job runs, processes via a headless browser on the ihateaudio.com tool page, deletes the input when the job ends, and returns links that expire after 1 hour. The expiry and cleanup behavior are exactly the kind of context annotations cannot convey.

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

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

Front-loads the core purpose and constraints well, though the sentence detailing R2 storage and the ihateaudio.com headless-browser pipeline is heavier than most agents need to select the tool. Still no wasted filler, just slightly over-detailed.

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

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

With no output schema, the description compensates by explaining that download links are returned and expire after 1 hour, plus the input-source and cleanup behavior. An agent has everything needed to call and 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?

Schema description coverage is 100%, so the schema already documents all three parameters, setting the baseline at 3. The description restates download_url, outputFormat and bitrateKbps and adds only examples ('mp3, wav, m4a') over what the schema provides.

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

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

States a specific verb+resource ('Converts audio to OGG Vorbis') that immediately distinguishes it from siblings like mp3_converter, wav_converter, flac_converter and m4a_converter. The target format is unambiguous.

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

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

The description makes the intended use implied by naming the target format and the required input (public HTTPS download_url), but it never states when to pick this over audio_converter or the other format converters, nor any exclusions. Adequate but with a clear routing gap.

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

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

Goes well beyond the annotations by disclosing the full data lifecycle: server downloads from download_url, retains the file in Cloudflare R2 for the job duration, processes via a headless browser, deletes the input at job end, and returns links that expire after 1 hour. That is exactly the retention/expiry/auth-free context the annotations cannot convey.

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

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

Front-loaded with the core operation and the key invariant in sentence one, then expands into I/O and infrastructure. Efficient overall, though the Cloudflare R2 / headless-browser implementation detail is closer to internals than agent-relevant information.

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

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

With no output schema, the description correctly covers the return value (download links expiring in 1 hour) and the input contract (one public HTTPS file). It lacks error/failure behavior, size or duration limits, and processing-time expectations for a multi-step media job.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds value by naming the backing tool page operation (set_pitch_shift with semitones/cents) and by qualifying outputFormat/bitrateKbps with 'where the tool supports them', flagging that some formats may reject bitrate. It does not enumerate valid semitone/cents ranges, which is the remaining gap.

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

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

States a specific verb+resource (shifts pitch by semitones and cents) plus the critical scope constraint 'without changing length', which cleanly separates it from speed_changer and tempo_changer in the sibling list. An agent can identify the operation without opening the schema.

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

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

The 'without changing length' clause implies the use case versus time-stretching tools, but there is no explicit when-to-use statement, no prerequisites, and no named alternative (e.g. speed_changer, voice_changer) to route between. Usage is inferable rather than stated.

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

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

Annotations declare a non-read-only, non-idempotent, non-destructive operation, and the description adds genuinely useful context beyond that: the server downloads the input, the input is held in Cloudflare R2 and processed headlessly, the input is deleted when the job ends, and output links expire after one hour. These lifecycle facts are not in the annotations. It does not cover failure/retry behavior.

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

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

Dense and front-loaded: the action, the input contract, the settings, and the output/lifecycle follow in a logical order. Slightly overpacked with implementation detail (Cloudflare R2, ihateaudio.com headless browser) that competes with actionable information, but every sentence carries information.

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

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

For a single-input effect tool with no output schema, the description covers the input source, processing pipeline, output link lifetime, and input deletion. The main gap is the meaning and constraints of the four reverb settings, which are listed but unexplained.

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

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

Schema coverage is 100% and the schema already documents download_url, file_id, bitrateKbps, and outputFormat. The description adds the names of reverb settings (space, decaySec, mix, preDelayMs) but not their semantics, ranges, or defaults, and the settings object schema is unbounded with no property descriptions. That leaves the reverb controls documented only by name in both places.

Input schemas describe structure but not intent. Descriptions should explain 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 effect: 'Adds convolution reverb.' That distinguishes it from effect siblings like echo_adder and slowed_reverb, though it never names those alternatives. Purpose is clear without sibling routing.

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

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

Usage is implied by the input contract ('one file with a public HTTPS download_url') and the optional reverb settings, but there is no explicit when-to-use, when-not-to-use, or ranking against the large set of audio-effect siblings. A competent agent can infer it, but the description provides no guidance beyond the mechanics.

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

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

Adds substantial context beyond the annotations: download links expire after 1 hour, the server downloads the file, holds it in R2 during processing, runs it through a headless browser, and deletes the input when the job ends. This is exactly the operational detail annotations cannot convey.

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

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

Front-loaded with the purpose in the first sentence, followed by input and options. Mostly efficient, though the detailed Cloudflare R2 / headless-browser infrastructure sentence is more than an agent needs to select or invoke the tool.

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

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

With no output schema, the description correctly covers the return value (expiring download links) and the required input. It is close to complete for a nested-input processing tool; the only real gap is not distinguishing itself from the very similar android_ringtone_maker sibling.

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

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

Schema description coverage is 100%, so the schema already documents download_url, settings keys, outputFormat, and bitrateKbps. The description largely repeats the settings keys and format examples, adding only the caveat the tool supports formats 'where the tool supports them.' Baseline 3 applies.

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

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

States a specific verb and resource: 'Cuts a section of a song into an M4R ringtone for iPhone.' The iPhone/M4R framing implicitly separates it from android_ringtone_maker, but it never names that sibling or distinguishes from m4a_converter/audio_trimmer.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'for iPhone' / M4R framing implies when to use it versus the android variant, and it states the required input (public HTTPS download_url). However, it never explicitly says when-to-use, when-not, or names an alternative, leaving routing 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?

Annotations only flag the operation as non-read-only, non-idempotent and non-destructive; the description adds substantial behavioral context beyond that. It discloses the download-link expiry (1 hour), the R2 staging lifecycle, the headless-browser processing path, and crucially that the input is deleted when the job ends.

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

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

Purpose is front-loaded in the first sentence and the parameter/return details follow in a logical order. The Cloudflare R2 and headless-browser infrastructure sentences are slightly verbose but do serve the transparency goal, so little is wasted.

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

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

With no output schema, the description carries the return-value burden and does so by stating that download links are returned and expire after an hour. Combined with input and lifecycle details, the definition is nearly complete, missing only explicit alternative-tool routing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real value: the 'settings' object in the schema is an open object with no defined properties, and the description tells the agent the key to place inside it (sampleRateHz). It also clarifies that outputFormat/bitrateKbps only apply 'where the tool supports them'.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Resamples audio to a different sample rate'), which cleanly separates it from the format-conversion siblings like mp3_converter or audio_converter. It never names those siblings explicitly, so an agent gets a clear purpose but no in-text routing cue.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 input requirements ('one file with a public HTTPS download_url') but no when-to-use vs when-not guidance and no mention of alternatives such as speed_changer or the format converters. The agent must infer the selection context entirely.

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

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

The description goes well beyond the annotations: it discloses that no email is sent, that download links expire after 1 hour, that the server fetches from download_url and stages the file in R2 during the job, that processing runs in a headless browser, and that the input is deleted when the job ends. This is the kind of lifecycle and side-effect detail annotations cannot carry.

Agents need to know what a tool does to the 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 key correction ('does not send any email') is front-loaded, which is good. But the trailing detail about Cloudflare R2, headless browser, and ihateaudio.com is infrastructure trivia that does not help an agent decide or invoke the tool, padding the length.

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

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

With no output schema, the description helpfully covers the return value (download links) and their 1-hour expiry, plus the input constraint and lifecycle. It is close to complete for invocation; the main omission is explicit routing against the resizing siblings.

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

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

Schema description coverage is 100%, so the schema already documents files, outputFormat and bitrateKbps. The description adds only a light qualifier that outputFormat/bitrate are honored 'where the tool supports them,' which marginally aids the agent. Baseline 3 is appropriate.

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

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

The description states a specific job: recompress or split audio to fit email attachment limits, and explicitly clarifies that it returns files rather than sending email. This resolves the apparent mismatch with its name. It stops short of naming the closest functional siblings (audio_compressor, audio_splitter) that also resize 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?

Usage is implied by the email-attachment-limit framing and the stated input requirement (a file with a public HTTPS download_url). However, it never states when to choose this over sibling tools like audio_compressor or audio_splitter, nor any exclusions. Adequate but clearly gapped.

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

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

Adds valuable context beyond annotations: input is downloaded from a public HTTPS URL, stored in Cloudflare R2 during the job, processed in a headless browser, deleted after the job, and results expire after 1 hour. However, it doesn't clarify permission/auth needs or why it isn't idempotent as annotated.

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

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

Front-loaded with the core purpose and a key clarification about not sending. However, the latter half contains implementation details (R2 storage, headless browser) that are tangential to invoking the tool correctly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 100% schema coverage, the description fills gaps by explaining return behavior (download links, 1-hour expiry) and input handling. It's nearly complete for a tool with these annotations.

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

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

Schema coverage is 100%, so parameters are already documented in the schema. The description only mentions outputFormat and bitrateKbps briefly, adding no syntax details beyond the schema. Baseline 3 is appropriate.

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

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

States a specific purpose: preparing audio to fit Discord's upload limit via recompression or splitting. It distinguishes itself from the many conversion siblings by routing to Discord-specific sizing, though the 'send' name is clarified by 'does not send anything to Discord'. Clear enough to identify the tool.

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

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

Explains what the tool does and that it doesn't send, but gives no explicit when-to-use vs alternatives like audio_compressor or audio_splitter. The Discord upload-limit context implies usage but isn't framed as 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?

Goes well beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotent=false) by disclosing that nothing is actually sent to WhatsApp, that output links expire after 1 hour, that the input is downloaded server-side into R2 only for the job's duration, and that processing runs via a headless browser. This data-retention and lifecycle detail is exactly what an agent needs before handing over a file.

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

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

Purpose and the crucial 'does not send' correction are front-loaded, and the sentences are dense with real information. It runs slightly long, with infrastructure detail (ihateaudio.com tool page, headless browser on Cloudflare) that is not needed for selecting or invoking the tool.

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

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

With no output schema, the description still explains return values (download links that expire in 1 hour) and covers input requirements, optional format/bitrate controls, and file lifecycle. Nothing an agent needs to call this job-style 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?

Schema description coverage is 100%, so the schema already documents files, bitrateKbps and outputFormat. The description restates the input shape and adds a mild nuance ('where the tool supports them') about format/bitrate support varying, but adds no syntax or constraint detail beyond the schema — the correct baseline of 3.

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

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

States a specific verb and outcome ('prepares audio to fit WhatsApp's 16 MB limit by recompressing it or splitting it at pauses') and immediately corrects the misleading name by asserting it 'does not send anything to WhatsApp'. That places it clearly apart from send_audio_by_email/send_audio_on_discord and from generic audio_compressor/audio_splitter siblings.

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

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

The WhatsApp 16 MB constraint gives clear context for when to reach for this tool rather than a generic compressor. It does not, however, name explicit alternatives or state when-not to use it (e.g. for non-WhatsApp targets).

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and idempotentHint=false, but the description adds substantial behavioral context beyond these: it explains the processing pipeline (download to Cloudflare R2, headless browser tool page), output link expiry (1 hour), and input deletion after job completion. This full lifecycle transparency is valuable for an agent managing user expectations. It doesn't contradict annotations. The only gap is not explaining why it's non-idempotent (e.g., whether re-runs produce identical output), but the description is otherwise 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 front-loaded with purpose, then parameters, then behavioral details. It is efficiently structured with no wasted sentences, though the pipeline explanation is somewhat lengthy. Every sentence earns its place, but could be slightly tighter.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 provides return value context ('download links for the result, which expire after 1 hour'). It covers input requirements, optional parameters, output format, and lifecycle behavior. However, it doesn't specify whether the output preserves the original format by default or explain what happens if outputFormat is omitted, leaving 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description restates the settings keys (threshold, minimumGapSec, paddingSec) and mentions outputFormat and bitrateKbps with examples, adding marginal clarity but not going beyond what the schema provides. Baseline 3 is correct when schema does the heavy lifting.

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

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

States a specific verb+resource: 'Shortens long silences in speech recordings.' This clearly distinguishes it from siblings like noise_remover (which removes noise, not silences) and audio_trimmer (which trims arbitrary segments). An agent can immediately tell what this tool does.

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

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

The description implies usage context ('speech recordings') but never states when to use this tool versus alternatives like audio_trimmer or noise_remover. It also doesn't clarify when silence removal is inappropriate (e.g., music). Usage is implied but no explicit when/when-not guidance is provided.

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

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

Goes well beyond the annotations, which only carry the generic readOnly/destructive/idempotent/openWorld flags. It discloses the full data lifecycle: the server downloads from download_url, stores the input in Cloudflare R2 for the duration of the job, processes it via a headless browser, deletes the input when the job ends, and returns download links that expire after 1 hour. That is exactly the kind of operational context an agent needs and cannot get from the schema.

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

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

Front-loaded with the operation and the input constraint before the settings/format details and the storage/disposal notes. Six sentences is slightly long and the settings enumeration mildly duplicates the schema, but every sentence carries usable information rather than 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?

With no output schema, the description takes on the return-value burden and does so ('download links for the result, which expire after 1 hour'), and it covers the required input shape, optional knobs, and retention/cleanup. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, and the description's parameter notes (settings keys intensity, speed, mix, decaySec; outputFormat examples; bitrateKbps) largely restate what the schema already documents, including the tool page that settings are passed to. It adds no syntax or value-range detail, so baseline 3 applies.

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

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

States a specific transformation ('slows a track down and adds reverb') and even names the composite edit it implements, which cleanly distinguishes it from the sibling single-effect tools reverb_adder and speed_changer without opening either schema.

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

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

Usage is implied by the phrase 'the slowed + reverb edit' and by the explicit input requirement (one file with a public HTTPS download_url), but the description never states when to pick this over speed_changer plus reverb_adder, nor any exclusions or prerequisites beyond the URL rule.

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

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

Adds substantial behavioral context beyond annotations: result links expire after one hour, the server downloads the public URL into temporary R2 storage, processes via a headless browser, and deletes the input when the job ends. This does not contradict destructiveHint=false because the deletion is of the server-side temporary copy, not the user's original file.

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

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

Front-loads the purpose, then moves through input constraints, settings, output, and lifecycle. All sentences are relevant, though the infrastructure detail is more expansive than strictly needed for tool 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?

No output schema exists, but the description explains the returned download links and their expiry. The input schema covers file structure, yet the free-form settings object and acceptable speed/pitch values are not specified, leaving a small gap.

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

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

Schema description coverage is 100%, so baseline is 3. The description repeats settings names (speed, keepPitch), output format examples, and bitrate, but adds little type or range detail; it also says 'one file' while the schema allows up to 12, creating minor ambiguity.

Input schemas describe structure but not intent. Descriptions should explain 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: changes playback speed, with or without pitch. The 'with or without changing pitch' phrasing distinguishes it at a high level from pure pitch-shifting or tempo-only tools.

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

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

The intended use case is implied by the name and capability, and input prerequisites are mentioned. However, there is no explicit when-to-use, when-not-to-use, or routing guidance against siblings such as pitch_shifter, tempo_changer, or audio_converter.

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

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

Annotations only carry the generic mutation profile, and the description goes well beyond them: it explains the download_url requirement, the R2 staging of the input during the job, headless-browser processing, that result links expire after 1 hour, and that the uploaded input is deleted when the job ends. Retention and expiry behavior are exactly the kind of traits an agent cannot get from the structured fields.

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

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

Purpose, input requirement, and link-expiry are front-loaded, which is good, but the mid-section detailing Cloudflare R2 storage and the ihateaudio.com headless-browser pipeline is implementation trivia that does not help an agent invoke the tool correctly. The description could shed those sentences without losing decision-relevant information.

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

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

With no output schema, the description correctly covers the return contract (download links that expire after 1 hour) and the input contract (one public HTTPS file). Given the nested file object and free-form settings bag, this is close to complete, though it stops short of clarifying the settings keys' accepted values.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the params (settings keys, outputFormat examples, bitrateKbps) but adds no format constraints or semantics beyond the schema — the 'settings' object keys (vocals, drums, bass, other) are named but their expected values remain undefined in both places.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Separates a song into stems') and enumerates the outputs (vocals, drums, bass, other), which cleanly distinguishes it from near-neighbors like vocal_remover and acapella_extractor. The mechanism ('by source separation') is named as well, so the agent knows exactly what operation is performed.

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

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

Usage is implied by the purpose statement, but the description never says when to pick this over siblings such as vocal_remover (isolate the instrumental) or acapella_extractor (isolate vocals). No exclusions, prerequisites, or alternative routing are given, leaving the agent to infer the choice from the operation 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?

Despite the annotations only covering the safety profile, the description discloses the full lifecycle: the server downloads the file, stores it in Cloudflare R2 while the job runs, processes it via a headless browser, deletes the input when done, and returns download links that expire after 1 hour. This is exactly the kind of post-annotations context that helps an agent reason about a non-idempotent, non-read-only 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?

Purpose is front-loaded in the first sentence and the rest is organized as input, options, return value, then backend behavior. The infrastructure sentence is longer than strictly needed, but each clause (storage location, processing, input deletion) carries behavioral weight rather than 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?

With no output schema, the description correctly compensates by describing the return (expiring download links), and it covers the async job lifecycle. The only genuine gap is the opaque `settings`/mode parameter, whose valid values remain undisclosed in both schema and 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?

Schema coverage is 100% for the top-level params, so the baseline is 3. The description attempts to clarify the otherwise empty `settings` object ('set_channel_mode: mode') but does not enumerate allowed mode values, and merely echoes outputFormat/bitrateKbps already documented in the schema.

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

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

The opening sentence gives a specific transform ('converts between stereo and mono, or keeps one channel'), which is clearly distinct from siblings like stereo_widener or audio_converter. It states the resource and the operation without ambiguity, though it never explicitly names a sibling to steer the agent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 by stating the input requirement (one file with a public HTTPS download_url) and the optional mode/format settings, but it never says when to pick this over stereo_widener or audio_converter, nor any exclusion or prerequisite conditions. Usage is inferable, 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?

Annotations only declare the generic mutation profile (readOnlyHint=false, destructiveHint=false), so the description carries the behavioral load and does it well: result links expire after 1 hour, the file is downloaded server-side, held in Cloudflare R2 only while the job runs, processed via a headless browser, and the input is deleted when the job ends. This lifecycle and retention detail is exactly the context annotations cannot supply.

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

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

Purpose is front-loaded in the first sentence, followed by input, parameters, output, and processing pipeline in a logical order. Slightly long, with infrastructure detail (R2, headless browser, Cloudflare) that borders on excess, but nothing is genuinely wasted.

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

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

No output schema exists, so the description correctly states the return value (download links, expiring after 1 hour) and also covers input requirements, optional parameters, and data-retention behavior. For a file-in/link-out processing tool this is complete enough to invoke correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description largely restates the schema ('settings for set_stereo_width: width', outputFormat examples mp3/wav/m4a), adding only the minor caveat 'where the tool supports them'; for the free-form settings object it offers no value range or units for width.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Widens or narrows the stereo image.' An agent can distinguish this from adjacent siblings like stereo_to_mono by function, but the description never names or contrasts a sibling, so full sibling differentiation is left to inference.

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

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

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The description only documents inputs and lifecycle; nothing tells the agent when to pick this over stereo_to_mono or equalizer.

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

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

Goes well beyond the annotations (which only say non-read-only, non-idempotent, non-destructive) by disclosing the full lifecycle: server downloads the file, keeps it in Cloudflare R2 during the job, processes it via headless browser, deletes the input at job end, and returns download links that expire after 1 hour. That is exactly the operational context an agent needs.

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

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

Front-loads the purpose and output artifact, then adds constraints and lifecycle in ordered sentences. The infrastructure detail (R2, headless browser on Cloudflare) is slightly verbose for tool selection but earns its place as behavioral context.

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

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

With no output schema, the description correctly covers the return value (download links) and its 1-hour expiry, plus input and lifecycle handling. The only gap is the unresolved tension between the subtitle deliverable and the audio-format examples for outputFormat.

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

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

Schema description coverage is 100%, so the baseline is 3; the description reinforces download_url being public HTTPS and that outputFormat/bitrateKbps are optional. However, the description repeats 'mp3, wav, m4a' examples for a subtitle tool whose stated output is SRT/VTT, which muddies rather than clarifies the outputFormat parameter.

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

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

States a specific verb and resource ('Transcribes speech and returns an SRT or VTT subtitle file'), so the agent knows exactly what it produces. It does not, however, differentiate itself from the sibling audio_transcriber, which an agent must disambiguate against on its own.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 specifies input preconditions (one file, public HTTPS download_url) and optional output settings, which implies context, but never states when to choose this over audio_transcriber or the various converter siblings. Usage is inferable 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 only generic annotations (write/idempotency hints), the description carries real weight: it discloses that download links expire after 1 hour, that the input is downloaded server-side into Cloudflare R2, that processing runs via a headless browser, and that the input is deleted when the job ends. These lifecycle and retention facts go well beyond what the annotations 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 core differentiator is front-loaded in the first sentence, and the structure moves sensibly from purpose to input to options to outputs. The pipeline detail (R2, headless browser on Cloudflare) is mildly extraneous but short enough to be tolerable.

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

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

With no output schema, the description correctly fills the gap by explaining that download links are returned and expire after an hour. Input requirements, optional settings and storage behavior are all covered; only minor ambiguities remain, such as the units/semantics of tempoPercent and the vague qualifier 'where the tool supports them'.

Complex tools with many parameters or behaviors need more documentation. 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 nominally 100%, but the nested 'settings' object is intentionally unconstrained (additionalProperties: {} with no defined keys), so the description's enumeration of valid keys (tempoPercent, bpm) is genuinely necessary information the schema does not provide. It also names example format values and explains the conditional nature of bitrateKbps, adding meaning over the schema.

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

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

States a specific verb+resource (changes tempo) and immediately qualifies it with the key differentiator 'without changing pitch', which separates it from siblings like speed_changer and pitch_shifter. An agent can route to it without opening the schema.

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

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

The phrase 'without changing pitch' implies when this tool is preferred over speed_changer, but no alternatives or exclusion conditions are named explicitly. Usage is inferable rather than stated, so this lands at minimum-viable.

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

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

Goes well beyond the annotations by disclosing the full lifecycle: the file is downloaded from download_url, stored in Cloudflare R2 during the job, processed via a headless browser, and deleted when the job ends, plus result links that expire after 1 hour. These operational traits (ephemeral storage, expiry, processing pipeline) are exactly the context an agent needs.

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

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

Purpose, input contract, output behavior, and lifecycle are front-loaded in that order, with no filler sentences. The infrastructure sentence (R2, headless browser, Cloudflare) is dense but carries real behavioral value rather than padding.

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

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

With no output schema, the description correctly steps in to describe the return (download links with a 1-hour expiry) and input cleanup. It stops short of clarifying which formats actually support bitrateKbps, a minor gap for a 3-param tool.

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

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

Schema coverage is already 100%, so the baseline is 3. The description earns extra credit by adding a caveat the schema lacks: outputFormat and bitrateKbps apply only 'where the tool supports them', flagging that valid values may be format-dependent and not universally accepted.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Extracts the audio track from a video file') with concrete input examples (MP4, MOV, MKV). It is distinguishable from the many audio-conversion siblings by its video input, though it never names a sibling to route against.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'Input: one file with a public HTTPS download_url' line implies the usage context, but there is no explicit when-to-use guidance or contrast against siblings like audio_converter or mp3_converter for already-audio inputs. Usage must be inferred.

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

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

Annotations cover only the safety profile (readOnly=false, destructive=false, openWorld=false, idempotent=false), but the description adds genuinely useful lifecycle detail: the server downloads the file, stores it in R2 during the job, deletes the input at job end, and the returned links expire after 1 hour. It omits expected processing duration and failure behavior, which keeps it from a 5.

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

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

Purpose is front-loaded in the first clause, followed by params, return behavior, and lifecycle. The Cloudflare R2 / headless-browser implementation detail is somewhat expendable for an agent choosing a tool, but it is contained and does not bury the actionable information.

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

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

With no output schema, the description correctly fills the gap by explaining that download links are returned and expire after 1 hour. Input constraints and format options are covered; only processing time expectations and error handling are missing.

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

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

Schema description coverage is 100%, so the schema already documents download_url, file_id, outputFormat and bitrateKbps. The description largely repeats this ('Optional outputFormat ... and bitrateKbps'), adding only the mild hint 'where the tool supports them' for format support. Baseline 3 applies when the schema carries the weight.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Removes the vocals from a song by source separation and returns the instrumental'), and the output wording implicitly distinguishes it from acapella_extractor (which yields vocals) and stem_splitter (which yields multiple stems). Siblings are not named explicitly, so it stops short of a 5.

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

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

The description conveys input constraints ('one file with a public HTTPS download_url') that imply when the tool is usable, but it never states when to choose this over acapella_extractor or stem_splitter, nor any exclusions. Usage is inferred rather than stated.

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

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

Goes well beyond the annotations by disclosing the full job lifecycle: the server pulls the file from download_url, parks it in Cloudflare R2, processes it via the ihateaudio.com tool page in a headless browser, deletes the input when the job ends, and returns download links that expire after 1 hour. These are exactly the traits (temporary storage, output expiry, deletion) an agent needs and that no annotation conveys.

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

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

Front-loads the purpose, then inputs, then outputs, then infrastructure in a compact paragraph with no filler. The final sentence on R2/headless-browser internals is the longest and least actionable, keeping it just short of a 5.

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

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

For a mutation tool with no output schema, the description covers the return value (expiring download links), input source, and cleanup behavior, which is nearly everything needed. The only remaining gap is the unresolved one-file-vs-twelve-files inconsistency with the schema's maxItems.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it names the settings sub-keys (preset, semitones), gives concrete outputFormat examples (mp3, wav, m4a), and scopes bitrateKbps to lossy formats 'where the tool supports them.' It slightly conflicts with the schema's maxItems of 12 by saying 'Input: one file.'

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

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

States a specific verb and resource ('Applies a voice effect preset or a pitch shift to a recorded voice'), which is far more informative than the title alone. It does not, however, name the closest siblings (pitch_shifter, nightcore_maker, slowed_reverb) or explain how the voice-effect preset differs from a plain pitch shift, so an agent must still infer the boundary.

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

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

Gives practical context (one input file with a public HTTPS download_url, optional settings/outputFormat/bitrateKbps 'where the tool supports them'), which implies how to call it. It never says when to choose this over pitch_shifter or speed_changer, and offers no exclusions, so usage 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?

Annotations only cover the generic safety profile (destructiveHint=false, idempotentHint=false), while the description adds substantive behavior: processing happens via the ihateaudio.com page in a headless browser on Cloudflare, inputs are stored in R2 only while the job runs, the input is deleted at job end, and result links expire after 1 hour. These are meaningful operational facts an agent needs to set expectations about latency and expiry.

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

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

Purpose is front-loaded in the first sentence and the remaining sentences group input, settings, output, and processing/lifecycle information efficiently. The infrastructure detail (R2, Cloudflare, headless browser) is somewhat verbose but each sentence conveys a fact that affects how the tool is called or how its results behave.

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

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

With no output schema, the description carries the return-value burden and does so ('returns download links for the result, which expire after 1 hour'), while also covering input requirements, optional settings, supported formats, and data-retention behavior. For a 4-parameter tool with a nested settings object, nothing critical is left unspecified.

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

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

Schema coverage is 100%, so the baseline would be 3, but the schema leaves the nested 'settings' object as additionalProperties: {} with no property details, and the description fills that gap by naming method, gainDb and targetPeakDbfs and by giving outputFormat examples plus the bitrateKbps caveat ('where the tool supports them'). That is genuine added meaning beyond the schema.

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

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

States a specific verb and resource: it 'raises the volume by a gain in dB or up to a target peak,' which is a clear, concrete operation. However, it never distinguishes itself from very similar siblings such as audio_normalizer or bass_booster, so an agent still has to infer which gain-based tool to pick.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative tool named. The only practical guidance is the implicit input constraint ('one file with a public HTTPS download_url'), which is really an input requirement rather than routing guidance.

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

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

Annotations only cover the generic read/write/idempotency profile; the description adds genuinely useful behavior an agent could not derive from them: the input is downloaded server-side, kept in Cloudflare R2 only while the job runs, deleted at job end, and the returned links expire after one hour. That directly informs data-retention and result-retrieval decisions, and nothing here contradicts the annotations.

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

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

The purpose and input constraints are front-loaded, which is good, but the back half drifts into implementation detail (Cloudflare R2, headless browser on Cloudflare) that does not help an agent select or call the tool. Roughly one sentence could be cut without loss.

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

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

With no output schema, the description usefully covers the return value (download links with a one-hour expiry) and the input lifecycle, which is enough for a 4-parameter conversion tool. Only the absence of any sibling-routing guidance 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?

Schema description coverage is 100%, so the schema already documents download_url, bitrateKbps and outputFormat; the description largely restates these. It does add a slight hint that bitrateKbps applies only 'where the tool supports them', but that falls short of the baseline-plus value a 4 would require.

Input schemas describe structure but not intent. Descriptions should explain 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 — converting audio to WAV at 16/24/32-bit — so the agent knows exactly what it produces. It does not, however, differentiate itself from the many sibling converters (audio_converter, flac_converter, mp3_converter), leaving the agent to infer that WAV is the fixed output.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 never says when to pick this tool over the large family of sibling converters or what the prerequisites are (other than that download_url must be public HTTPS). There is no 'when-not-to-use' or named alternative, so routing must be inferred 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?

Goes well beyond the annotations (readOnlyHint=false, destructiveHint=false, idempotentHint=false): it discloses that return links expire after 1 hour, that the file is fetched from download_url and held in Cloudflare R2 only for the job's duration, that processing occurs in a headless browser, and that the input is deleted when the job ends. This is exactly the lifecycle and retention context an agent needs and nothing contradicts the annotations.

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

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

Purpose is front-loaded and the sentences are dense with information, but the mid-sentence infrastructure paragraph (R2 storage, headless browser on Cloudflare) is slightly verbose for what the agent needs. Still largely earns its place through retention/expiry disclosure.

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

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

With no output schema, the description correctly compensates by explaining the return (download links with a 1-hour expiry) and the full input/storage lifecycle. The remaining gap is that the settings values and defaults are unexplained, which matters given the settings object is an untyped free-form map.

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

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

Schema description coverage is 100%, so the baseline is 3. The description merely recites the settings keys (preset, widthPx, heightPx, style, waveColor, backgroundColor, transparent) that the schema's settings description already lists, adding no value ranges, defaults, or format semantics.

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

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

States a specific verb and resource ('Draws a PNG image of the waveform') plus the output artifact type, which immediately distinguishes it from every sibling (all of which transform/convert/analyze audio rather than render an image). An agent can identify this as the visualization tool without opening the schema.

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

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

Implies usage via the input constraint (a single file with a public HTTPS download_url) and notes the settings are optional, but it never states when to pick this tool over siblings or what conditions favor it. Given the sibling set is operationally distinct, this is adequate but leaves selection to inference.

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