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

With no annotations provided, the description fully discloses behavior: it returns sections only for configured providers, details the fields per provider (tier, limits, quality), and explains error handling. This goes far beyond a simple 'get status' statement.

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

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

The description is well-structured with a clear opening sentence, then two bullet-like sections for each provider. Every sentence adds value, and the formatting improves scannability without being bloated.

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

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

Given no output schema and no parameters, the description thoroughly covers return structure, per-provider details, and edge cases (providers with errors). It provides all needed context for an AI agent to understand what will be returned.

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

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

There are zero parameters, so the baseline is 4. The description instead focuses on output semantics, which is appropriate. Since there are no parameters to document, this is effectively complete.

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

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

The description clearly states the tool's function: 'Credits + quotas for ALL configured providers in one call' with a specific verb (check) and resource (account status). It also distinguishes from siblings by emphasizing provider-wide coverage and pre-fan-out use.

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

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

Explicit guidance is given: 'check before fan-out' and 'Use it to avoid mid-batch failures... and to pick a supported audio format.' It also clarifies that per-provider errors are isolated, which helps decide when to call this tool.

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

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

No annotations are provided, so the description carries the burden. It discloses a meaningful side effect ('consumes one custom-voice slot...') and describes return values. It doesn't cover potential failures or idempotency, but the disclosure is solid.

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

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

The description is concise and well-structured: a clear opening sentence, a workflow note, a warning, and a returns section. Every sentence adds value without redundancy.

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

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

For a simple tool with three string params and no annotations, the description covers purpose, usage, side effects, and return format. It lacks explicit error handling details, but overall it is sufficiently complete for an agent to invoke correctly.

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

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

With 0% schema description coverage, the description fully compensates by explaining that public_owner_id and voice_id come from search_voice_library, and that name is the saved name. All three parameters are semantically defined.

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

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

The description clearly states the action ('Add a shared Voice Library voice to the account and save it under `name`'), identifying the specific resource and outcome. It also references search_voice_library and generate_speech, distinguishing this from sibling tools.

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

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

It provides explicit workflow context ('Take public_owner_id + voice_id from search_voice_library. After this, generate_speech(voice="<name>") uses that character'), which indicates when to use it. However, it does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

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

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

With no annotations provided, the description carries the full burden. It states it adds rules (implying mutation) and shows a return shape, but it does not disclose permissions, reversibility, idempotency, or any side effects like versioning. For a mutation tool, this is a significant transparency gap.

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

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

The description is compact and well-structured with Args and Returns sections. Every sentence contributes meaning; there is no fluff. It is easy to scan and understand.

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

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

The description covers the core operation and parameters, and provides a return format. However, with no annotations and no output schema, it lacks broader context such as when to choose this tool, error scenarios beyond a generic error object, and any prerequisite knowledge besides referencing another tool. It is adequate but not fully complete.

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

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

The schema has no descriptions, so the description compensates by explaining 'dictionary' as a saved name or id and 'rules' as a map or list of EL rule objects. It adds meaning beyond the bare property names, though it defers detailed rule structure to another tool, which is a partial gap.

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

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

The description clearly states the tool adds rules to an existing pronunciation dictionary, specifying that the dictionary can be referenced by saved name or id. This is a specific verb+resource pairing that makes the main function clear, though it does not explicitly contrast with sibling tools like create_pronunciation_dictionary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 (you'd use this when you want to add rules to an existing dictionary) but does not provide explicit when-to-use or when-not-to-use guidance. It does reference create_pronunciation_dictionary for rule object format, which is a cross-reference, but lacks alternatives or exclusions.

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

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

Without annotations, the description carries the burden of disclosing side effects. It mentions 'Consumes a voice slot' and that after the call, 'speak(...)' can use the speaker, providing key behavioral context. It does not detail error cases or permissions, but core effects are covered.

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

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

The description front-loads the core purpose in the first sentence, then concisely notes the combination, side effect, and usage note. The Args list is direct without filler. Each sentence earns its place.

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

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

For a tool with no output schema, the description covers purpose, side effects, and parameters. It lacks an explicit return value description, but considering the simple create-and-save nature and the presence of sibling tools for lookup, this is a minor gap. Overall it's complete enough for an agent to use it correctly.

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

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

The description explains each parameter beyond schema titles: 'name' as handle, 'public_owner_id' and 'voice_id' as from preview_voices candidate, 'workspace' as namespace, 'seed' as optional base seed, and 'description' as human note. This compensates for the 0% schema coverage.

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

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

The description clearly states the tool's function: adding a Voice Library voice and saving it as a speaker in one step. It explicitly references the combined tools 'add_library_voice + save_speaker', distinguishing it from sibling tools.

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

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

The description indicates when to use this tool: when you want both add_library_voice and save_speaker simultaneously. It also notes the resulting effect on 'speak' usage. This provides clear context for choosing this tool over separate alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does this well by explaining the return record shape, the possible statuses (queued/running/succeeded/failed), that failed records include an error, and that unknown ids return status 'unknown'. Missing details like rate limits or authentication, but these are not critical for a polling tool.

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

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

The description is concise and well-structured: a one-line summary, a context sentence, and a return-format explanation. Every sentence adds useful information without redundancy or fluff.

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

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

Given the simple one-parameter schema and no annotations, the description is quite complete. It covers purpose, usage context, input meaning, output shape, statuses, and error handling. The only minor gap is lack of details about rate limits or permissions, but these are not essential for an agent to invoke this tool correctly.

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

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

The input schema only defines job_ids as an array of strings with zero description coverage, so the description must compensate. It does so by clarifying that each id produces one status record and that unknown ids are handled gracefully. It doesn't specify ID format or maximum batch size, but the semantic purpose of the parameter is well conveyed.

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

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

The description uses a specific verb and resource: 'Batch-poll jobs by id'. It clearly distinguishes this tool from sibling tools like list_jobs by emphasizing polling specific IDs and noting it is 'the companion to fan-out generation'. This makes the tool's role unambiguous.

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

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

The description gives clear context by stating this is the companion to fan-out generation, implying it should be used after generating jobs in batch. However, it does not explicitly mention alternatives or when not to use it, such as 'use list_jobs to enumerate jobs', so it falls short of a perfect score.

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

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

With no annotations, the description carries the full burden. It discloses that the tool consumes one voice slot, requires a tier, saves under the provided name, and is immediately usable. It also explains the remove_background_noise parameter's effect. This is rich behavioral context beyond what any structured data would provide.

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

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

The description is well-structured and front-loaded, with a clear summary, ethical note, and parameter list. It is slightly longer due to the detailed guidance, but every sentence earns its place. A minor typo ('ofaudio') prevents a perfect score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four parameters, no output schema, and no annotations, the description covers the tool's purpose, usage, parameter semantics, side effects (voice slot), prerequisites (tier), and ethical considerations. It even references related tools (generate_speech, account_status). This is highly complete for the tool's complexity.

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

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

Schema coverage is 0%, but the description's Args section explains every parameter: name as the handle, audio_paths as readable files, description as optional stored text, and remove_background_noise as the denoiser flag. This fully compensates for the lack of schema descriptions.

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

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

The description uses the specific verb 'clone' and resource 'voice', clearly stating 'Clone a voice from audio sample(s) — ElevenLabs Instant Voice Cloning.' It distinguishes from siblings like generate_speech, which uses a voice, and save_voice which likely saves existing voices. The scope is well-defined.

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

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

The description provides explicit usage context: requires audio files on the machine, recommends ~1-2 minutes of clean single-speaker audio, and states the result is immediately usable with generate_speech. It also mentions prerequisites (tier allowing instant cloning, see account_status) and includes an important consent warning. This is clear when-to-use guidance with inferred alternatives.

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

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

With no annotations, the description carries the full burden. It discloses core behavior (voice swap preserving timing), format downgrade behavior ('wav auto-downgrades to mp3 on sub-Pro tiers'), and noise removal as a pre-processing step. However, it omits potentially important side effects such as whether the original audio file is modified, network/credit consumption, or authentication requirements.

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

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

The description is well-structured with a brief summary, a use-case sentence, an Args block, and a Returns block. Every sentence adds value; there is no redundancy or filler. The front-loaded summary immediately conveys what the tool does.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 five parameters and no output schema, the description is remarkably complete. It includes a return format, parameter details, and specific format/behavior nuances. Minor gaps include explicit error scenarios and prerequisites (e.g., account tier or parent workspace), but overall it is self-contained enough for an agent to use correctly.

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

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

Schema coverage is 0%, so the description must compensate, and it does. Each parameter gets a functional explanation beyond the schema: audio is 'Local path to the source audio', voice is 'a saved name or an ElevenLabs voice id', format includes allowed values and downgrade caveat, and seed is 'Optional determinism hint.' All five parameters are addressed, though 'seed' could be more precise about its effect.

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

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

The description clearly states the action ('Re-voice a recorded performance onto another voice') and the resource (ElevenLabs speech-to-speech). It explicitly distinguishes this from sibling tools by emphasizing that it 'keeps the delivery/timing of the input recording but swaps the voice,' positioning it for dubbing, ADR, and character voice conversion.

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

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

The description gives clear use-case context: 'for dubbing, ADR, or turning your own take into a character's voice.' It does not explicitly name alternatives or state when not to use, but the distinction from text-to-speech tools (like generate_speech) is strongly implied through the focus on existing recordings.

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

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

With no annotations, the description carries the burden of disclosing behavior. It explains that the dictionary is saved by name and reusable, and it specifies the return value. However, it does not disclose what happens if a name already exists (overwrite vs error) or any permission requirements.

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

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

The description is well-structured: a clear one-sentence summary, a usage paragraph, a structured args list, and a returns section. Every sentence adds value, and it is appropriately sized given the tool's complexity.

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

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

The description provides a complete picture: what the tool does, how to use the resulting dictionary, the exact parameter formats, and the return value. It even references related tools (generate_speech/speak, save_speaker) for applying the dictionary, making it fully actionable for an agent.

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

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

Schema description coverage is 0%, so the description must fully explain the parameters. It does so thoroughly: name is explained as a handle for reuse, rules are detailed with two formats (alias map and IPA phoneme objects) and examples, and description is noted as optional. This compensates completely for the schema's lack of descriptions.

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

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

The description clearly states the tool creates a pronunciation dictionary, with a specific verb ('Create') and resource. It explains the function and provides a concrete use case, making the purpose unmistakable even without 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 clear context on when to use the tool (for consistent pronunciation of names/terms) and how to apply the result (pass to generate_speech/speak or pin to a speaker). However, it does not mention alternatives like add_pronunciation_rules or specify when not to use it.

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

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

With no annotations, the description fully carries the transparency burden. It highlights destructive/irreversible nature, the confirm=True requirement, name-to-id resolution with ambiguity refusal, prohibition on premade voices, removal of local aliases, and profile-pinning warnings. This goes far beyond a basic delete operation.

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

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

The description is front-loaded with the core action, followed by critical warnings and a clear Args section. Every sentence adds value, from the destructive warning to the side-effect notifications, with no redundancy or filler.

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

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

Given the tool's complexity, absence of annotations, and lack of output schema, the description is remarkably complete. It covers safety, side effects, edge cases like ambiguous names and premade voices, and parameter semantics, giving an agent sufficient information to invoke correctly and anticipate consequences.

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

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

Schema coverage is 0%, so description must compensate. It explains 'voice' as a name or ID, clarifies ambiguity behavior, and defines 'confirm' as a required safety flag. This adds essential meaning beyond the raw types in the schema.

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

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

The description explicitly states the tool's purpose: deleting a custom voice from the ElevenLabs account, with the specific effect of freeing a voice slot. It clearly distinguishes from siblings like list_voices, get_voice, and clone_voice by focusing on deletion of custom voices only.

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

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

The description provides clear context on when to use (deleting custom voices) and when not to (premade voices cannot be deleted), plus practical guidance around confirm=True and resolving ambiguous names. It does not explicitly name alternative sibling tools, but the exclusions and operational notes make usage context strong.

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

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

With no annotations, the description carries the full burden. It transparently discloses side effects (previews saved to output dir, save_as consumes a custom-voice slot), reproducibility via seed, parameter ranges, and the return format including error handling. This goes well beyond minimal expectations.

Agents need to know what a tool does to the 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 a brief workflow, then structured Args and Returns sections. Every sentence adds value, and the length is justified by the complexity of 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?

Given the lack of annotations and output schema, the description is remarkably complete: it covers all parameters, side effects, workflow steps, and return format. No critical gaps are apparent.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining every parameter: description, save_as (with slot consumption), text (including character range), model (with defaults), guidance_scale (range and effect), loudness (range and default), and seed (reproducibility). This is exemplary.

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

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

The description clearly states the tool designs a brand-new custom voice from a text description (ElevenLabs Voice Design) and provides a concrete example. This distinguishes it from sibling tools like clone_voice, convert_voice, or preview_voices.

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

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

The description gives a clear workflow: describe the voice, get previews, audition them, then keep one via save_voice or pass save_as to auto-save. It implies when to use this tool versus alternatives, but does not explicitly state exclusions or name alternative tools as comparisons.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core behavior (snapping text to audio), the output format (word/character counts, loss, captions path), and optional caption writing. However, it does not explain what 'loss' means or how mismatches between script and audio are handled, leaving some behavioral ambiguity.

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

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

The description is well-structured with intro, usage guidance, args, and returns. Every sentence contributes value; no fluff. It is longer than typical but earns its length with dense, useful information.

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

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

For a tool with no output schema and no annotations, the description is quite complete: it explains purpose, args, return values, and usage context. However, the 'loss' return field is left undefined, and error conditions or failure modes are not mentioned, leaving minor gaps.

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

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

Schema has 0% description coverage, but the Args section fully compensates: audio ('Local audio file path'), text ('exact transcript/script'), captions ('srt' or 'vtt' to also write a subtitle file'). This adds meaning well beyond the bare titles in the schema.

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

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

The description opens with a specific verb and resource: 'Align a KNOWN script to existing audio → exact per-word timings'. It clearly distinguishes the tool from siblings by contrasting with `transcribe`, which discovers words, while this snaps given text to 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?

Explicitly states when to use: 'Use when you already have the exact transcript...' and names the alternative (`transcribe`) with a clear distinction. This gives the agent actionable selection criteria.

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

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

No annotations are provided, so description carries the burden. It discloses async behavior (returns job_id and queued status, with check_jobs returning the audio path), seed determinism, and support for v3 audio tags. It does not mention error handling beyond an error object or permission/authorization needs, but covers key behavioral traits.

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

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

The description is well-structured with a one-line summary, benefit statement, constraints, an Args list, and a Returns section. It is detailed but every sentence adds value, with no filler.

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

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

Given no annotations, no output schema, and 7 parameters with 0% schema coverage, the description provides all necessary context: purpose, usage, parameter semantics, constraints, and return/status behavior. It is fully sufficient for an agent 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 description coverage is 0%, and the description fully compensates by explaining every parameter with types, defaults, and examples. For lines, it details the structure and optional fields; for apply_text_normalization, it lists enum options; and for engine, it explains the provider override.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Generate a multi-speaker dialogue scene in a single call.' It distinguishes from siblings by explicitly comparing to generate_speech ('better than stitching N separate generate_speech calls').

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

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

Explicitly names alternative generate_speech and explains why this tool is preferred for multi-speaker scenes. Also gives constraints (up to 10 voices, ~2000 chars), providing clear context for when to use it.

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

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

With no annotations, the description carries the full burden, and it delivers: it discloses synchronous behavior, returns immediately, returns text not audio, and includes the return format. It adds practical insights about reviewing/editing before spending credits and error handling. However, it does not mention any potential cost implication for the lyrics generation itself or rate limits, which are minor for such a simple tool but keep it from a perfect score.

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

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

The description is concise and well-structured: first the core purpose, then the synchronous/usage rationale, then the Args and Returns sections. Every sentence adds important information, with no redundancy or fluff. It is front-loaded with the most essential details.

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

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

For a simple tool with one parameter and no output schema, the description is remarkably complete. It covers purpose, behavior, parameter semantics, return format, and even workflow guidance with a sibling. The context is fully sufficient for an agent to invoke this tool correctly without additional research.

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

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

The schema only provides the parameter name 'prompt' and type 'string', which is minimal. The description compensates with a clear semantics: 'The theme/brief' and a concrete example ('a hopeful song about starting over in a new city'). This fully clarifies what the parameter expects, adding significant value over the schema.

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

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

The description opens with a specific verb and resource: 'Write song lyrics from a theme/description (Mureka)'. It immediately distinguishes itself from siblings like generate_music by clarifying 'returns text, not audio', and further differentiates by mentioning the synchronous, credit-aware workflow. This makes the tool's purpose unmistakable.

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

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

The description explicitly states when to use this tool: 'before spending song credits' and 'Great for getting the words right first'. It also names the alternative, generate_music, and explains how to pass the generated lyrics to it, giving clear usage context and exclusions. This is exemplary guidance for an agent.

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

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

With no annotations provided, the description carries the full burden. It discloses the async job behavior, engine-specific parameter handling, output format defaults, and side effects like store_for_inpainting persisting songs. This goes well beyond a simple 'generates music' claim.

Agents need to know what a tool does to the 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 long but every sentence earns its place. It front-loads the async behavior, then systematically documents each parameter with concise, high-signal details and a short Returns section. No filler or redundancy.

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

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

Given 11 parameters, two engines, no annotations, and no output schema, the description is remarkably complete. It covers return values, job polling, defaults, engine differences, mutual exclusions, and relevant downstream effects, leaving little ambiguity for an agent.

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

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

Schema description coverage is 0%, so the description must compensate—and it does admirably. Every parameter gets a plain-language explanation, type/format hints, examples, and engine-specific constraints (e.g., reference is Mureka-only, count is 1–3). This significantly enriches the bare schema.

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

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

The description opens with a clear verb and resource: 'Generate music — a theme, background track, song, or instrumental bed.' This specific enumeration distinguishes it from sibling tools like generate_sfx, generate_speech, and generate_dialogue, making the tool's purpose immediately clear.

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

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

The description explains the asynchronous workflow ('Returns immediately with a job_id... Poll it with check_jobs') and provides engine-selection guidance (Mureka vs ElevenLabs), mutual exclusions (prompt OR composition_plan), and parameter applicability per engine. It effectively tells the agent when and how to use this tool.

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

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

With no annotations, the description fully discloses the asynchronous behavior (returns job_id immediately), the polling mechanism via check_jobs, engine defaults (ElevenLabs), and parameter-specific behavior (e.g., prompt_influence, loop semantics). It also includes the return value shape, including error case.

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

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

The description is well-structured with a summary line, async note, parameter list, and return value description. It uses bullet points and examples without unnecessary verbosity, and every sentence contributes useful information.

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

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

Despite having no output schema or annotations, the description covers the full lifecycle: what the tool does, how to use parameters, async workflow, and expected return values. It is complete for a generation tool with 7 parameters.

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

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

Schema description coverage is 0%, and the description compensates fully by explaining every parameter: prompt with examples, duration range, loop behavior, prompt_influence scale, model override, engine override, and format defaults. This adds critical meaning beyond the bare schema.

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

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

The description clearly states 'Generate a sound effect' and specifies the subtypes (one-shot, ambience, seamless loop), distinguishing it from sibling tools like generate_music or generate_speech. The verb and resource are specific and unambiguous.

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

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

The description gives clear context for use (e.g., 'great for ambience/BGM beds') and workflow guidance (poll with check_jobs), but it does not explicitly state when not to use this tool or mention alternatives. However, the tool's scope is well-defined by its name and description.

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

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

No annotations are provided, so the description carries the full burden. It transparently discloses key behaviors: immediate job_id return and polling via check_jobs, seed non-determinism ('NOT bit-exact'), variants behavior returning job_ids, with_timestamps sidecar, and profile override logic. These details set accurate expectations for the agent.

Agents need to know what a tool does to the 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 long but densely informative. It opens with the async workflow, then provides a structured Args list mapping to all 18 parameters, followed by a clear Returns contract. There is no redundant filler; every sentence serves the agent's invocation decision.

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

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

Given the tool's complexity (18 params, no annotations, no output schema), the description covers purpose, workflow, parameter semantics, return shape, and caveats such as seed reproducibility and v3 expressiveness. It is complete enough for an agent to use effectively without additional context.

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

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

With 0% schema description coverage, the description fully compensates by explaining every parameter's meaning, defaults, and interplay. For example, it clarifies that profile presets are overridden by precision knobs, explains stability mode options and semantics, and describes pronunciation dictionary usage. This adds substantial value beyond bare property names.

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

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

The description clearly states 'Generate spoken dialogue / character voice acting', which is a specific verb+resource combination. It distinguishes itself from sibling tools like generate_music and generate_sfx by focusing on speech. The async nature and workflow further differentiate it from simpler speech tools.

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

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

The description provides clear usage context: it is for generating dialogue/voice acting asynchronously, encourages firing multiple calls for a scene, and references related tools (check_jobs, list_profiles, save_profile, list_voices). However, it does not explicitly state when not to use this tool or compare it directly to alternatives like generate_dialogue or speak, so it misses the explicit exclusion criteria for a 5.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the operation returns specific fields and works by name or id, but it does not mention error behavior, permissions, rate limits, or explicitly confirm read-only status, though 'get' implies non-mutating behavior.

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

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

The description is a single sentence that front-loads the purpose and uses a colon to concisely list the returned fields. There is no wasted wording or unnecessary detail.

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

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

For a simple one-parameter getter with no output schema, the description adequately covers the return fields and parameter semantics. It doesn't detail error responses or exact result shape, but the tool's simplicity makes the information sufficient for correct invocation and expectation.

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

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

The schema only defines 'voice' as a required string with no description. The description's 'by name or id' provides crucial meaning, explaining what values the parameter accepts. This significantly compensates for the 0% schema description coverage.

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

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

The description clearly states this tool retrieves details for a single voice, listing specific returned fields (category, labels, description, preview_url). This distinguishes it from siblings like list_voices (multiple voices) and preview_voices (audio preview).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when you need details for one voice by name or id, but it does not explicitly mention when to use it over alternatives like list_voices or search_voice_library. No exclusions or alternative tools are named.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core behavior (removing noise/isolating voice) and the return format, but does not mention potential side effects, processing constraints, or whether the original file is modified. This is adequate but not rich.

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

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

The description is concise and well-structured: a purpose statement, a usage context sentence, and clearly labeled Args/Returns sections. Every sentence contributes information, with no redundant filler.

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

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

For a single-parameter tool with no output schema and no annotations, the description covers purpose, usage context, parameter meaning, and return format. It is nearly complete, but could benefit from mentioning whether the original file is preserved or any error conditions beyond the generic 'error'.

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

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

The schema has 0% description coverage for the 'audio' parameter, but the description adds meaning by specifying 'Local path to the audio file to clean.' This clarifies that the parameter is a filesystem path, not a URL or ID, and the purpose. It does not mention file formats or size limits, so it stops short of a 5.

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

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

The description opens with a specific verb and resource: 'Remove background noise / isolate the voice from an audio file', which clearly defines the tool's purpose. This distinguishes it from siblings like generate_speech or transcribe, which handle different audio tasks.

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

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

The description gives clear context for when to use the tool: 'For cleaning up field recordings, podcast takes, or noisy clips before further use.' It does not explicitly mention alternatives or exclusions, but the use cases are well-defined. This is just short of the explicitness required for a 5.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does provide useful behavioral details: ordering ('newest first'), default limit (50), and accepted status values. However, it omits potential details like pagination beyond the limit, what 'recent' means in terms of time window, or whether the tool is read-only (though 'List' implies this).

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

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

The description is extremely concise and front-loaded with the main purpose. The Args section is compact and each line earns its place. No unnecessary words or redundancy.

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

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

For a simple list tool with an output schema present, the description is largely complete: it covers the action, ordering, filtering, and parameter options. However, it leaves ambiguity around the 'recent' window and does not mention pagination or offset support, which could be relevant for large result sets. These gaps are minor given the tool's simplicity.

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

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

Schema description coverage is 0%, so the description fully compensates by explaining both parameters in detail: status lists allowed values (queued/running/succeeded/failed) and clarifies omission means 'all'; limit states the default (50) and purpose. This adds meaning beyond the schema's bare types and defaults.

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

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

The description uses a specific verb 'List' with a clear resource 'jobs' and states ordering ('newest first') plus an optional filter by status. This distinguishes it from sibling tools like check_jobs by making its scope explicit.

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

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

The description implies usage (to list recent jobs, optionally filtered by status) but does not explicitly state when to use this tool versus alternatives such as check_jobs or other job-related tools. There is no when-not-to-use guidance, so usage context is only implied.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It adds useful context: it's a read-only listing (implied by 'List'), scope is 'available on the account', and it enumerates the returned fields (model_id, name, can_do_tts, etc.). This exceeds the bare verb and gives the agent a good sense of what to expect.

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

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

The description is extremely concise: two short sentences plus a field listing. Every sentence earns its place, and the most important information (what it does) is front-loaded. The field list is presented as a compact inline list, avoiding redundancy.

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

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

Given the tool has no parameters and an output schema exists, the description is complete. It tells the agent what the tool returns, the scope (account), and the practical use case. There are no gaps that would leave the agent confused about when or how to invoke this tool.

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

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

The tool has zero parameters, so the description doesn't need to explain parameter semantics. The schema is empty, and the baseline for 0 params is 4. The description does mention how to use the returned model_id (via `model=`), which is a nice touch beyond the schema.

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

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

The description clearly states the tool's purpose: 'List ElevenLabs models available on the account, with capability flags.' It uses a specific verb (List), identifies the resource (ElevenLabs models), and specifies the account scope. It also distinguishes itself from sibling listing tools by focusing on models and their capabilities.

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

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

The description provides explicit usage guidance: 'Use to pick or confirm a model id before pinning it via `model=`.' This tells the agent when to use the tool. It doesn't explicitly exclude alternatives, but the sibling tools are clearly for other resources (voices, profiles, etc.), so the context is clear.

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

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

With no annotations provided, the description is the sole source of behavioral information. It does not explicitly state that the operation is read-only, does not describe the return format or any pagination or ordering behavior, and does not mention potential use cases or limitations. The description is purely functional and lacks behavioral depth.

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

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

The description is a single concise sentence that front-loads the verb and resource. It includes a clarifying elaboration on the contents, adding value without unnecessary verbosity.

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

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

While the tool is simple with no parameters, the description omits any indication of the return structure or how this relates to sibling tools like list_voices. Without an output schema, the description could be more complete by specifying typical response content or the relationship to other list tools. It is adequate but has clear gaps in context.

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

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

The input schema has zero parameters, so the description requirement is minimal. The description's mention of 'everything saved' appropriately indicates no filtering. Given the baseline of 4 for zero-parameter tools, this score is justified.

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

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

The description uses the verb 'List' and specifies the resource 'presets registry', further clarifying the contents as 'speaker voices and music identities'. This clearly distinguishes it from sibling tools like list_voices or list_speakers by anchoring to the registry concept.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_voices or list_speakers. It simply states what it does without any contextual cues, exclusions, or alternative mentions.

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

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

With no annotations provided, the description carries the disclosure burden. It clearly explains that the list includes built-in presets and saved profiles, and describes what each entry contains (name, built-in flag, delivery settings). For a read-only list operation, this is sufficient and transparent.

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

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

The description is two short sentences, front-loaded with the main verb and resource. Every sentence adds value: one defines the tool, the second explains the output and usage. No wasted words.

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

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

For a zero-parameter tool with an output schema (present but not shown), the description provides all necessary context: what is listed, where the data comes from (built-in + saved), and how to use the results. It is complete and self-sufficient.

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

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

The tool takes zero parameters, and the description correctly avoids inventing any. The baseline of 4 applies because there are no parameters to explain.

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

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

The description opens with 'List speech profiles' which clearly states the action and resource. It further distinguishes these from voices by noting they are 'built-in delivery presets plus any saved via save_profile.' This separates it from sibling tools like list_voices.

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

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

The description explicitly tells the user to use a profile name with generate_speech(profile="<name>"), which clarifies a primary use case. It does not explicitly discuss alternatives, but the context of siblings (e.g., list_voices) and the defined scope makes the intended usage clear enough.

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

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

With no annotations, the description carries the full burden. It transparently indicates a read-only listing operation, and even discloses the return shape (name → id/version). It does not mention side effects or access requirements, but for a simple list tool this is sufficient.

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

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

Two concise sentences front-load the purpose, then provide practical usage guidance. Every word earns its place with no redundancy or filler.

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

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

Given the zero-parameter schema and the presence of an output schema, the description fully covers what the tool does, what it returns, and how to apply the results. It is complete for an agent to select and use this tool correctly.

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

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

The tool has zero parameters, so the baseline is 4. The description adds meaning by explaining the output format and how to use the returned values, which is valuable context beyond the empty schema.

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

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

The description clearly states the tool's function: 'List saved pronunciation dictionaries' with a specific verb and resource. It also specifies the output format (name → id/version), which distinguishes it from other list tools and provides clear scope.

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

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

The description explicitly points to alternative tools for applying a dictionary ('generate_speech/speak pronunciation= or save_speaker pronunciation='), giving clear context on when this listing tool is useful. It lacks an explicit 'when not to use', but the alternative guidance is strong.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. It adds useful context about the entity composition ('voice + base delivery') and that workspace filtering is optional, but it omits explicit statements about read-only semantics, default behavior when workspace is null, or any side effects, leaving some assumptions implicit.

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

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

The description is a single sentence of nine words, front-loaded with the verb and resource, with no filler. Every phrase adds value: 'saved speakers' clarifies scope, the parenthetical defines the entity, and the final clause explains the optional parameter.

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

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

For a simple list tool with one optional parameter and an output schema, the description is largely complete, covering the resource, entity composition, and scoping. It could be slightly clearer about whether omitting workspace returns all speakers, but this is a minor gap given the low complexity and existing output schema.

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

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

Schema description coverage is 0%, but the single 'workspace' parameter is addressed by the description's 'optionally within one workspace', which conveys that the parameter is an optional filter. This adds meaning beyond the schema's type/default, though it does not elaborate on accepted workspace identifiers or behavior when omitted beyond the schema's type and default.

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

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

The description uses a specific verb ('List') and identifies a clear resource ('saved speakers'), further clarifying that speakers consist of 'voice + base delivery'. This distinguishes it from sibling tools like list_voices, which target a different resource, and the optional workspace scoping is explicitly stated.

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

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

The description does not explicitly state when to use this tool over alternatives such as list_voices or list_profiles, nor does it name exclusions or alternatives. The phrase 'optionally within one workspace' hints at a common use case, but the usage guidance is essentially implied by the resource name and parenthetical rather than spelled out.

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

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

With no annotations, the description carries full burden. It discloses the output schema (account and profiles keys, along with voice fields) and that it returns both types, which is meaningful behavioral context. It doesn't explicitly mention read-only behavior, but 'list' strongly implies it.

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

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

The description is three concise lines: a clear purpose statement, a structured return format description, and a practical usage hint. There is no wasted wording, and the most important information is front-loaded.

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

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

For a simple list tool with no output schema, the description fully covers the return structure and how to use the results with generate_speech. It also notes the inclusion of profiles, which is a key behavioral detail. No significant gaps for this complexity level.

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

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

The tool has zero parameters, and the baseline for 0 params is 4. The description correctly adds no parameter information since none are needed, and the schema covers the empty parameter set completely.

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

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

The description clearly states the tool lists ElevenLabs voices plus saved speech profiles, which is a specific verb+resource. It distinguishes itself from siblings like list_profiles by explicitly including both account voices and profiles, and it provides the return structure with field names.

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

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

The description provides downstream usage guidance (how to use a voice or profile name with generate_speech), but it does not explicitly say when to use this tool instead of siblings like list_profiles. The usage context is implied rather than explicitly contrasted with alternatives.

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

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

Without annotations, the description carries the behavioral disclosure burden. It discloses the read-only nature through the verb 'List' and adds scoping context ('currently hold speakers'), but it does not mention any ordering, filtering semantics, or access limitations. This is sufficient for a basic list operation.

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

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

The description is a single concise sentence with no filler. It front-loads the action and resource, earning a perfect score.

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

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

Given the tool has no parameters, an output schema, and a clearly scoped purpose, the description provides enough context for an agent to select and invoke it. The sibling list tools are distinguished by the workspace-specific scope.

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

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

There are no parameters in the input schema, so the description has nothing to add regarding parameter semantics. The schema covers 100% of parameters (none exist), which meets the baseline for 0-parameter tools.

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

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

The description uses a specific verb ('List') and resource ('workspace namespaces') with a scope qualifier ('that currently hold speakers'), clearly distinguishing it from sibling list tools like list_voices or list_speakers. It goes beyond a mere restatement of the tool name.

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

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

The description implies usage for retrieving workspaces that have speakers, but it does not explicitly state when to prefer this over other list tools or mention any alternatives/exclusions. For a simple list tool, this is adequate but lacks explicit guidance.

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

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

With no annotations, the description carries the transparency burden. It discloses that this is a non-consuming preview ('No generation, no voice slots consumed') and that it returns preview_urls. It does not cover all edge cases, but the key behavioral guarantee is present.

Agents need to know what a tool does to the 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-organized: a purpose statement, a usage tip with next step, and a concise Args list. Every sentence adds value, and the structure is scannable without being overly verbose.

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

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

The description gives a complete workflow from previewing to adding a speaker, including the exact function call with required parameters. It lacks explicit return structure details, but for a preview tool this is sufficient.

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

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

Schema coverage is 0%, but the description compensates by explaining query as a short role term with examples, filters as optional labels, and n as the count with a default. This provides meaning beyond the raw 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?

The description clearly states the tool's function: 'Preview voices for a role — search the Voice Library and return top candidates' with preview_url. It distinguishes itself from siblings like search_voice_library by emphasizing the preview_url output and 'No generation, no voice slots consumed.'

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

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

Provides explicit guidance: 'Library voices sound better than designed ones — search here first' and instructs to use add_speaker_from_library after picking a candidate. This makes the intended workflow clear and includes a direct alternative comparison to designed voices.

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

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

With no annotations, the description carries full burden. It discloses important side-effects: shadowing built-in names, mapping to generate_speech knobs, and seed-locked consistency. It does not mention permissions or idempotency, but the disclosed behaviors go well beyond a bare 'save profile' statement.

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

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

The description is well-structured with a purpose paragraph, a context paragraph, and an Args list. It is as long as needed for 11 parameters, with no filler or redundant repetition of schema defaults.

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

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

For a complex 11-parameter tool with no annotations and no output schema, the description covers the tool's purpose, usage relationship, parameter semantics, and a key side-effect (shadowing built-ins). It provides everything an agent needs to invoke it correctly.

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

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

Schema coverage is 0%, and the description fully compensates by documenting all 11 parameters in the Args section with types, examples, and value constraints (e.g., stability accepts 'creative'/'natural'/'robust' or 0-1, seed range 0-4294967295). This adds real meaning beyond the raw schema.

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

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

The description opens with a specific verb+resource: 'Save a reusable speech profile (a persona/mood preset)'. It clearly distinguishes from siblings by explaining that profiles bundle delivery settings so generate_speech(profile="<name>") reproduces them, contrasting with voice/speaker save tools.

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

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

Provides clear context on when to use: to create reusable presets for generate_speech. Explains design choices (pin voice+seed vs voice-agnostic mood) and warns about shadowing built-in profiles. Does not explicitly name alternative tools, but context implies this is for speech presets, enough to guide selection.

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

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

With no annotations, the description must carry behavioral disclosure. It does explain that pronunciation is applied automatically and that delivery parameters are base defaults overridable per line. However, it omits what happens if a speaker with the same name already exists (e.g., overwrite behavior) and any auth/rate-limit details, which is a notable gap for a save operation.

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

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

The description is well-structured: a clear opening sentence, a brief conceptual explanation, and a compact parameter list. Every sentence adds value, and the grouped parameter line for delivery settings keeps it concise despite the high parameter count.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 thoroughly covers the parameters and conceptual model, but there is no output schema and the description does not mention what the tool returns (e.g., saved speaker object, success message) or potential failure scenarios. This missing return-value context is a gap for a save tool with no structured output contract.

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

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

The description compensates for 0% schema coverage by clearly explaining all 12 parameters. It gives concrete examples (e.g., name as 'narrator'), defines voice as ElevenLabs voice or saved clone, lists the base delivery parameters as a group, and explains pronunciation's automatic application. This adds substantial meaning beyond the raw schema.

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

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

The description clearly states a specific action: 'Save a reusable SPEAKER — a pinned voice + its base delivery — under a workspace.' It distinguishes the tool from siblings by contrasting speaker (identity) with profile (mood), making its purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 when to use this tool by defining the speaker concept and how it relates to `speak` and profiles. It also gives practical guidance on workspace usage to avoid collisions. However, it doesn't explicitly mention when not to use it or refer to alternative tools like `save_profile` by name.

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

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

With no annotations, the description discloses the key side effect: it consumes one custom-voice slot. It also clarifies that the saved voice becomes available to generate_speech. It doesn't mention overwrite behavior or reversibility, but covers the main behavioral contract.

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

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

The description is concise and well-structured: a one-line purpose, a two-sentence behavioral note, and a compact Args list. Every sentence adds value with no redundancy.

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

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

For a tool with no annotations and no output schema, the description gives a complete picture: where the input comes from, what side effect occurs (slot consumption), and how the result is used later (with generate_speech). All parameters are explained, and the tool's place in the broader workflow is clear.

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

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

Schema coverage is 0%, so the description must explain parameters. It does so fully: 'name' is the handle to save under, 'generated_voice_id' is the preview id from design_voice, and 'description' is optional metadata stored on the voice. This adds clear meaning beyond the bare schema titles.

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

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

The description clearly identifies the specific action (saving a designed voice preview) and its resource (from design_voice, as a permanent reusable voice). It distinguishes the tool from siblings like delete_voice and list_voices by tying it to the design->save->generate workflow.

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

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

The description provides clear context: it should be used after design_voice and before generate_speech. It explains the prerequisite and downstream usage, but doesn't explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It warns that long queries 'over-match and return almost nothing' and recommends short queries and filters, which is a key behavioral trait. It also discloses the return structure and how to use results with add_library_voice. However, it doesn't mention rate limits, error handling, or other edge cases, but for a search tool the disclosed behavior is substantial.

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

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

The description is well-structured with a clear opening, usage guidance, query-length warning, then organized Args and Returns sections. It is longer than minimal but every section contributes necessary information for 8 parameters and no output schema. Slightly verbose but not wasteful.

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

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

Given no annotations and no output schema, the description is remarkably complete. It covers the tool's purpose, usage workflow, parameter semantics, return format, and integration with sibling tools like add_library_voice. All 8 parameters are explained, and the return value is described with the important note about public_owner_id + voice_id. No critical gaps remain.

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

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

The input schema provides only names and types with zero descriptions. The description's Args section adds concrete meaning for every parameter, including examples ('raspy', 'gruff'), allowed categories ('professional', 'famous', 'high_quality'), specific use_cases ('characters_animation', 'narrative_story'), and page_size constraints (1-100, default 20). This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states the tool's purpose: 'Search ElevenLabs' shared Voice Library — thousands of ready-made voices.' It distinguishes itself from alternatives by positioning it as 'how you pick a voice instead of dialing one out of parameters,' and connects to downstream tools like add_library_voice and generate_speech.

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

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

Explicitly states when to use this tool: as the alternative to manually specifying voice parameters. It provides a clear workflow (search → filter → add → generate) and offers practical advice on query length and filter usage. It also mentions specific example queries and filter values, giving the agent concrete guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the processing pipeline (resolving speaker, layering mood, applying overrides), return behavior (job_id or job_ids for variants), and side effects (timestamps sidecar). It also notes v3 audio tag support. Missing details about latency, cost, or failure modes, but sufficient for a generation tool.

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

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

The description is well-structured with a concise summary paragraph followed by a bulleted argument list. The first sentence is a punchy purpose statement, and each argument is described in one line. The length is justified for 13 parameters, but the 'engine / format' line could be more explicit.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 13-parameter tool with no output schema and no annotations, the description provides substantial context: return values, sidecar outputs, variants, and parameter precedence. The main gaps are the undocumented 'pronunciation' parameter and the indirect engine/format reference. Overall, it gives an agent enough information to use the tool correctly in most cases.

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

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

Schema description coverage is 0%, so the description must compensate. It explains speaker, text, mood, workspace, per-line overrides, variants, and timestamps. However, 'pronunciation' is completely omitted, and 'engine / format: as generate_speech' relies on external reference without inlining the semantics. Despite the gap, the description adds meaningful meaning to most parameters.

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

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

The description opens with 'Speak a line as a saved SPEAKER, optionally in a MOOD,' a specific verb-resource pairing that clearly identifies the tool's function. It distinguishes itself from siblings like generate_speech by emphasizing the use of a saved speaker, making the purpose immediately clear.

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

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

The description offers clear contextual guidance, directing users to list_speakers for valid speaker names and noting that engine/format parameters follow generate_speech. It implies when to use this tool (when a saved speaker exists) but does not explicitly name alternatives like generate_dialogue or generate_speech as substitutes.

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

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

With no annotations provided, the description carries the full burden and excels: it discloses input types (local file/URL), optional behaviors (language forcing, diarization, caption file generation), and the exact return format including an error case. This is rich behavioral detail beyond a simple one-liner.

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

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

The description is well-structured with a purpose line, Args, and Returns sections. Every line provides actionable information without fluff, making it easy to scan while remaining complete.

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

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

Given the tool's complexity (4 parameters, optional captions output), the description covers all inputs, behaviors, and return values. The optional captions_path is explained, and the error return is acknowledged, making the description self-contained despite the lack of an output schema.

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

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

The description adds substantial meaning to every parameter: audio accepts a local path or URLs including YouTube/TikTok, language is an ISO code with auto-detect default, diarize labels speakers, and captions accepts 'srt' or 'vtt' and returns a path. This fully compensates for the 0% schema description coverage.

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

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

The description clearly states the tool's verb and resource: 'Transcribe speech to text' using ElevenLabs Scribe. It also lists concrete use cases (podcasts, meetings, captions, dubbing prep) that distinguish it from sibling tools like forced_alignment or generate_speech.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 clear use-case context ('for podcasts, meetings, captions, dubbing prep') and explains when options like diarize or captions should be enabled. However, it does not explicitly name alternative tools or state when NOT to use this tool, so it stops short of full exclusionary guidance.

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