NiceVois

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

Annotations already establish that this is a non-readonly, non-destructive, open-world operation. The description adds useful behavior beyond that: account entitlement/subscriber unlimited use, the free convert_format exception, and the upload-URL-then-get_audio_job workflow. It does not cover auth mechanics or failure behavior, but it adds meaningful operational context.

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

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

The description is front-loaded with the tool scope and then adds account, free-tier, and workflow context. It is somewhat dense with enumerated tool names and parentheticals, but every sentence supports selection or invocation.

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

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

For a multi-tool audio job creation endpoint with an output schema and 80% schema coverage, the description supplies the important non-schema context: supported tools, account requirement, free convert_format exception, and post-creation step. Remaining gaps around detailed parameter behavior and job lifecycle are covered by structured fields or are minor.

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 80%, so the schema already explains fileName, sizeBytes, outputFormat, and durationSeconds well. The description does not add parameter-level meaning beyond listing the allowed tool values, which are already captured by the enum.

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

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

The description states that this tool supports every NiceVois audio tool and lists the available operations, making the resource and scope clear. It does not explicitly say 'creates an audio job' and does not name create_free_audio_job as a sibling alternative, but an agent can still tell what this tool does.

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

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

It gives a clear account-based usage condition: with a connected account the selected tool runs on that account, and convert_format is free and also works with no account. It also states the follow-up workflow ('Returns an upload URL; then use get_audio_job'), though it does not explicitly route no-account users to create_free_audio_job.

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

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

Annotations only declare non-readonly, open-world, non-destructive; the description adds real context: it consumes a shared website allowance, requires OAuth or an agent key, needs no paid subscription, and is a two-step create-then-upload flow returning an upload URL. That disclosure goes materially beyond the annotations. It stops short of saying what the allowance costs per job or what happens when the allowance is exhausted.

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

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

Purpose is front-loaded, which is good, but 'using the same account allowance as the website' and 'No paid subscription is required for the free allowance' restate the same free-tier point across two sentences. Tightening would remove a redundant line without losing information.

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

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

With an output schema present and full schema descriptions, the description supplies the missing operational layer: authentication route, allowance model, and the follow-up get_free_audio_job call. An agent could call this correctly. Limits on allowance consumption per job and supported size ceilings are the only notable omissions.

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

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

Schema coverage is 100%, with enum values and format guidance fully documented, so the baseline is 3. The description contributes one useful implication – that no audio bytes are passed, instead an upload URL is returned – which explains why fileName/sizeBytes exist, but adds nothing about the individual 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?

States a specific action set (split stems, isolate vocals, remove noise/reverb) on a specific resource (audio job) and signals the free-allowance tier that separates it from create_audio_job. It never names that paid sibling, so the differentiation is only implied by 'free account' and 'no paid subscription'.

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 next-step ('Returns an upload URL, then use get_free_audio_job'), which is genuine workflow guidance. But it never says when to choose this over create_audio_job, nor any exclusions such as file size or duration limits, so selection between the two creation tools is left to inference.

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

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

Beyond the annotations, the description discloses key behavioral details: it returns a one-time PUT upload URL, allocates a private training slot, and does not start GPU work until upload and start_training. It also explains the CONSENT_REQUIRED retry flow and the acceptsStandingAgreement flag, which is valuable operational context.

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

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

The description is front-loaded with purpose and return behavior, then covers consent handling and lifecycle constraints. Every sentence adds useful operational information without wasted wording.

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

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

The description covers the create/upload/start lifecycle and consent behavior well, and an output schema exists so return values need not be detailed. However, for a 9-parameter tool with only 33% schema description coverage, the lack of parameter explanations leaves a significant completeness gap.

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

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

Schema description coverage is only 33%, so the description should compensate for undocumented parameters. Instead, it adds little meaning for most parameters such as epochs, modelName, submissionId, sizeBytes, contentType, and durationSeconds, and its mention of acceptsStandingAgreement largely restates the schema.

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

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

The description states a specific verb and resource: it creates a private NiceVois training job and returns a one-time PUT upload URL. It also clarifies the lifecycle relative to start_training, but it does not explicitly differentiate itself from other creation siblings such as create_audio_job or create_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?

It gives clear consent-handling guidance and indicates that start_training must be called after upload before GPU work begins. However, it does not explicitly state when to choose this tool over sibling creation tools or describe any when-not-to-use conditions.

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

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

Goes well beyond the annotations by disclosing the quota cost model (one conversion per create, three free, five-minute cap, credit returned on failure), that listening and downloads are free, and that the call returns a private upload instruction rather than a result. These are consequential, non-obvious behaviors for a non-readOnly, openWorld tool.

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

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

Front-loaded with the trigger condition and the follow-up call, then the quota rules. It is a single dense paragraph with no filler, though the billing and workflow details packed into one block make it slightly harder to scan than a split would be.

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

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

With an output schema present, the description needn't explain return values, and it instead covers the parts the schema cannot: the upload handoff, the follow-up tool, and the quota accounting. Nothing an agent needs to invoke this correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents modelId, transpose, wholeSong, durationSeconds and the terms flag in detail. The description only echoes the 'private voice model' selection and the upload-only-source constraint, adding little parameter-level meaning beyond the structured fields — the correct baseline of 3.

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

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

States a specific verb and resource ('convert one vocal recording') plus the precondition ('user has selected a private voice model'), which cleanly separates it from create_audio_job and create_training_job. An agent can distinguish it from every sibling without opening a schema.

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

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

Gives an explicit trigger condition ('when the user has selected a private voice model and wants to convert one vocal recording') and a follow-up step ('Upload only the source vocal, then call get_voice_conversion with the same conversion ID'). It does not explicitly rule out the audio-job siblings, so it stops short of full when/when-not coverage.

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

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

The description adds valuable behavioral context beyond the annotations: it states that the tool returns a one-time PUT upload instruction, implying a temporary upload URL and requiring an external upload step. It also hints at the tool being non-mutating (it only prepares) and non-destructive, aligning with the annotations (readOnlyHint=false, destructiveHint=false). However, it does not detail authentication requirements or what happens if the upload is not completed, which would be extra context.

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

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

The description is two sentences, front-loaded with the primary purpose and usage trigger, and clearly explains the return and next step. It contains zero filler and every sentence adds value, making it an excellent example of conciseness and structure.

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

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

Given the presence of an output schema (which likely describes the PUT upload instruction) and the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description is fairly complete. It explains the purpose, the trigger, and the follow-up action. However, it could briefly mention that the upload URL is temporary or that the tool does not actually upload the file, which would improve completeness, but the current description covers the essential workflow.

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

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

The schema already provides clear descriptions for both parameters: fileName as the original .pth or .zip filename, and sizeBytes with a max limit. The description adds no additional parameter-specific meaning beyond what the schema states, and with schema coverage at 50% (the schema describes both parameters but may not cover all aspects like encoding or extensions), the baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: to prepare a private RVC model upload, specifying what the user wants (convert with an existing private RVC .pth file or ZIP) and that it returns a one-time PUT upload instruction. This distinguishes it from siblings like creating a training job or converting with a library voice, and it is consistent with the 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 explicitly states when to use this tool ('when the user wants to convert with an existing private RVC .pth file or complete model ZIP instead of a voice trained in their NiceVois library') and provides a clear next step ('After uploading, call list_voice_models to select the imported voice'). This provides strong usage guidance and names an alternative action (using a library voice) and a follow-up action.

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

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

Annotations only declare it is not read-only, not destructive, and open-world; the description adds real economics (downloads are free, billing was counted once at conversion start) and a repeat-download safety protocol requiring user confirmation. It does not cover auth/permission requirements or whether output links expire, keeping it short of a 5.

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

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

Three short sentences, with the precondition and the artifact scope front-loaded and the repeat-safety caveat last. No filler or restatement of the title.

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

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

An output schema exists, so return values need no explanation; the description covers the gating call, billing implications, and the repeat-confirmation workflow. The only material omission is the role of eventId, which neither schema nor description explains.

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 50%: kind and confirmRepeat are already documented in the schema, and the description merely reinforces confirmRepeat's rule. The undocumented eventId is never explained in the description, so it does not compensate for the coverage gap.

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

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

The description states a specific verb+resource (download the completed voice conversion output) and names the artifacts available (cleaned vs standard). It implicitly separates itself from get_voice_conversion by tying invocation to that tool's completion status, though it never explicitly contrasts with the other download-ish siblings such as get_audio_download.

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

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

Gives an explicit precondition ('Use after get_voice_conversion says the job is complete') and an explicit branch condition for the repeat case ('If the exact file was downloaded before, ask before retrying and then set confirmRepeat true'). The when-to-use and when-to-ask-first conditions are both 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?

The description adds important behavior beyond the annotations: the link is short-lived and should be used immediately. It does not explain why readOnlyHint is false despite the retrieval-style operation, nor does it disclose permissions or whether repeated calls create new links.

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

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

Two tight sentences front-load the purpose and then the required action. There is no redundant restatement of the tool name or title.

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 key operational fact, link expiration, and the tool has an output schema plus annotations covering safety. It could be slightly more complete by explicitly routing to get_audio_job for valid output stems, but nothing critical is missing.

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

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

With 50% schema description coverage, the output parameter is documented in the schema while jobId is not. The description contributes 'completed audio job' as a constraint on jobId and 'one output' as the meaning of output, but it adds no format or selection guidance 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 states a specific verb and resource: it returns a link to one output of a completed audio job. It is clear enough to distinguish from create_audio_job and generic job inspection, though it does not explicitly name sibling tools like get_audio_job or download_voice_conversion_output.

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

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

The phrase 'completed audio job' implies the prerequisite that the job must already be finished, and 'Download it or give it to the user straight away' gives a usage action. However, it does not explicitly say when to use this versus get_audio_job for listing outputs or download_voice_conversion_output for conversion outputs.

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

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

Annotations already declare this a safe, closed-world read, so the description correctly spends its words on lifecycle behavior instead: polling pattern, terminal states, and that results are enumerated only once complete. It does not cover rate limiting or empty-output cases, which keeps it from a 5.

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

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

Two tight sentences ordered by lifecycle: prerequisite first, terminal condition second, follow-up action last. Nothing is redundant with the title or schema.

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

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

For a single-parameter polling tool with full schema coverage, an output schema, and safety annotations, the description supplies the missing behavioral layer (polling, terminal states, handoff). Only edge behavior such as transient errors or status value meanings is left unstated, and those are minor.

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

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

Schema coverage is 100% and the jobId field already documents 'The id returned by create_audio_job.' The description only indirectly references this origin, adding no format or validation detail beyond the schema, so baseline 3 applies.

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

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

The description makes clear this is the status-check counterpart to create_audio_job, polled until the job reaches a terminal state, and that it enumerates outputs on success. The verb 'check' only appears in the title, not the description, but the resource and lifecycle role are unmistakable and clearly distinct from get_audio_download.

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

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

It states exactly when to call it (after create_audio_job plus the upload), how long to keep calling (until completed or failed), and what to do next (get_audio_download for selected outputs). The alternative sibling is named rather than merely implied.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=false, so safety is covered; the description adds that the answer reflects the 'current free-beta policy', signaling time-sensitive content. It does not say the call is parameterless or that results are static/instantaneous, and the output schema already covers the return shape.

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

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

Two sentences: the trigger condition first, then an enumerated content list. Front-loaded and free of filler, though the second sentence reads as a comma-separated inventory rather than a tight summary.

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, read-only lookup with an output schema, the description supplies what the agent actually needs: when to call it and what subject matter comes back. Nothing critical is missing, though a pointer to create_voice_conversion as the follow-up action would close the loop.

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?

Zero parameters, so the baseline of 4 applies; there is nothing for the description to disambiguate 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?

States a specific resource (RVC voice conversion requirements) and enumerates what the answer contains: input formats, model choices, workflow, free-beta policy, outputs. It implicitly contrasts with the sibling create_voice_conversion (which performs conversion) by being the requirements lookup, but never names that sibling.

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

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

Opens with an explicit trigger: use this when a user wants to convert vocals with RVC or compare a normal RVC result with NiceVois cleaned consonants. That gives a clear when-to-use condition, though it never states exclusions or points to get_training_requirements for the analogous training path.

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

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

Beyond read-only annotations, the description discloses a concrete polling rate limit ('no more than every 10 seconds'), the terminal states ('completed or failed'), and what the completed response contains (output files with download links). These are meaningful operational details for correct invocation.

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

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

Two sentences with no filler. The polling cadence and lifecycle condition are front-loaded, and the return-content note is included only where useful.

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

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

For a simple one-parameter polling tool with annotations and an output schema, the description covers the key behavioral gaps: when to call, how often, when to stop, and what completion yields. Nothing essential is missing.

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

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

Schema coverage is 100%, and the single jobId parameter is already documented in the schema as the id returned by create_free_audio_job. The description reinforces that same relationship but adds no additional syntax or constraints beyond the structured field.

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

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

The description clearly implies polling a free audio job created by create_free_audio_job, and states it runs until the job completes or fails. It does not explicitly differentiate this from the sibling get_audio_job, but the 'free' workflow context and named create_free_audio_job make its purpose clear.

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

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

It gives explicit usage context: call after create_free_audio_job and the upload, poll no more than every 10 seconds, and stop when completed or failed. It does not name alternatives or exclusions, so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint and destructiveHint, so the safety profile is covered. The description adds valuable behavioral context beyond that: it explains the account-scoped nature of the call and the private browser link that preserves agent identity through checkout, which is a meaningful side effect an agent needs to know about.

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

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

Two sentences with no filler: the usage precondition is front-loaded, and the returned data is enumerated without redundancy. Every clause 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?

With an output schema present, return-field details are already structured. The description covers when to invoke it, what to expect, and the identity-preserving checkout-link behavior. Nothing an agent needs to call it correctly is missing.

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

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

The tool has zero parameters, so there is no parameter syntax to document. The description clarifies that it operates on the connected account's identity, which is useful context and merits the baseline 4 for a parameterless tool.

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

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

The description states a specific purpose: a preflight check of the connected account's training balance and credits, returning welcome-credit status, available/reserved balance, balance packs, and a checkout link. It clearly distinguishes this account-level balance tool from siblings like get_training_job, which operate on individual jobs.

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

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

It explicitly tells the agent when to call this tool — before quoting or creating a training job — which is clear, actionable guidance. However, it does not name alternatives or state when not to use it (e.g., when checking an existing job's status).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by explicitly stating it is for a 'private' training job and that the tool is meant for polling (implying it is non-mutating and safe to call repeatedly, with a rate hint). No contradictions found.

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

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

The description is two sentences with zero waste. All information is relevant and front-loaded: first sentence states the tool's purpose and scope, second adds a crucial usage constraint. Every word earns its place.

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

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

Given it has an output schema (so return structure is documented), only 1 required parameter with clear purpose, and annotations already cover safety, the description covers all necessary ground. It explains what the tool does, how to use it (polling with rate limit), and distinguishes it from siblings. No 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?

Schema coverage is 0%, meaning the description must compensate. It does not describe the 'jobId' parameter explicitly, but the tool's purpose ('check one training job') strongly implies jobId identifies which job. With only one required parameter, the context is sufficient. A brief clarification of what jobId looks like would merit 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 uses a specific verb ('check'), states a clear resource ('one private NiceVois training job'), and explicitly lists what it retrieves ('stage, completed epochs, ETA, and artifact readiness'). This effectively distinguishes it from sibling tools like create_training_job or list_training_jobs.

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 when to use this tool ('to check one training job') and provides proactive usage guidance ('poll reasonably; do not call more often than every 15 seconds'). This helps the agent avoid misuse or excessive calls.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral context by enumerating exactly what information the tool confirms, including consent requirements and retention, which goes beyond the annotations.

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

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

The description is a single, well-structured sentence that front-loads the usage instruction ('Use this before training') and then efficiently lists the key requirement categories. Every phrase adds value 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?

For a zero-parameter, read-only requirements tool with an output schema, the description is complete. It tells the agent when to use it, what to expect (formats, limits, consent, outputs, retention, upload workflow), and implicitly distinguishes it from action-oriented sibling tools.

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

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

The input schema has zero parameters, so the baseline is 4. There are no parameter semantics to explain, and the description appropriately focuses on the tool's informational output rather than inputs.

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

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

The description clearly states the tool's purpose: to retrieve RVC training requirements before training. It lists specific content areas (input formats, duration/epoch limits, consent, outputs, retention, upload workflow), which distinguishes it from sibling tools like create_training_job or start_training that perform actions rather than provide requirements.

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 says 'Use this before training an AI voice,' giving clear temporal guidance for when to invoke the tool. It does not explicitly name alternatives or exclusions, but the pre-training context is strong enough to guide selection among the siblings.

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

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

With annotations already marking this as read-only and non-destructive, the description adds meaningful behavior beyond that: it discloses polling cadence, instructs the agent to report the actual returned stage without inventing progress, and prescribes output ordering. These are non-obvious behaviors not available from annotations or schema.

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

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

Three short sentences, each earning its place: one sets the use case, one sets polling and accuracy expectations, one prescribes the post-completion action. The most important instruction is front-loaded, and there is 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?

The task is a simple read/status check with a single parameter. An output schema is present, so return-value documentation is already covered. The description adds all necessary operational guidance: polling limit, honest reporting, and the correct downstream 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 schema has 0% description coverage and the prose does not mention conversionId, its origin, or how it relates to create_voice_conversion. Though the tool name and the word 'conversion' hint at the identifier's meaning, the description provides almost no value beyond the schema's property name and constraints.

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

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

The description names a specific verb ('check') and resource ('one private NiceVois conversion'), and the title reinforces 'Check an RVC vocal conversion.' It clearly separates this polling/status tool from related creation and download operations, so an agent knows what it does without inspecting the schema.

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

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

The description gives explicit when-to-use context ('Use this when checking') and a hard usage rule ('Poll no more than once every 10 seconds'). It also names the companion tool to use after completion, download_voice_conversion_output, providing a clear alternative and handoff.

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

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

Annotations already declare readOnly/non-destructive/closed-world, so the safety profile is covered; the description adds genuinely new context—no-account requirement for listing versus shared allowance for processing—plus the practical guidance to hand the website link to the user when upload isn't possible. It doesn't mention rate limits or catalog size, but the important behavioral traits are disclosed.

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

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

A single front-loaded sentence with the usage trigger first, followed by the tool inventory and return contents. The parenthetical list of synonyms (vocal remover, acapella, karaoke instrumental) is slightly verbose but earns its place for matching user phrasing.

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

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

An output schema exists, so return values need not be spelled out, yet the description still summarizes the key fields (id, accepted formats, website link) and gives the downstream action to take with them. For a parameterless listing tool with full annotation coverage, nothing an agent needs is missing.

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

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

The tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. The description correctly implies a parameterless catalog call without introducing any false input expectations.

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

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

States a specific verb and resource ('see NiceVois's free audio tools') and then enumerates the actual tool categories (vocal split, lead/backing split, noise removal, de-reverb). This makes it clearly distinguishable from the sibling processing tools like create_free_audio_job and get_free_audio_job, which act on a single job rather than cataloging options.

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 frames discovery vs. processing ('discovery needs no account; processing shares your account allowance') and gives a concrete trigger ('when you cannot upload their file yourself'). It stops short of naming the sibling to call after discovery, but the when-to-use condition 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is safe. The description adds that it lists only 'recent' jobs and for the 'authenticated user', which is useful but not extensive. No additional behavioral details like pagination or sorting are provided.

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 is front-loaded with the action and resource, and every word adds meaning. No redundant or filler content.

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

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

Given the tool has no parameters, clear annotations, and an output schema that describes return values, the description covers the essential purpose and usage guidance. It could mention that it only lists recent jobs, but the output schema likely defines the structure. Overall, it's complete for this simple 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 input schema has no parameters, and schema description coverage is 100% (trivially). The description adds context by specifying 'recent' and 'authenticated user's', which clarifies the scope implied by the empty schema. A score of 4 reflects that the description effectively handles the parameter-free case.

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

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

The description clearly states the verb 'list' and the resource 'private RVC training jobs', and specifies it returns the authenticated user's recent jobs. It distinguishes itself from siblings like 'get_training_job' which likely retrieves a single job by ID.

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

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

The description explicitly states to use this tool before asking for a job ID, providing clear use-case context. However, it doesn't explicitly mention when not to use it or compare directly with siblings like 'get_training_job' or 'start_training'.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the readonly nature is covered. The description adds transparent context about what the tool returns access to: the user's private NiceVois-trained or uploaded RVC voices, and signals that calling it is a prerequisite before conversion. This is meaningful beyond the structured annotations.

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

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

The description is two sentences with no filler. It front-loads the primary use case and immediately follows with an actionable constraint, making the tool's purpose and invocation behavior easy to absorb.

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

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

Given zero parameters, an output schema, and read-only annotations, the description provides the necessary context for a simple list-and-select tool. It states when to invoke it, what it exposes, and a behavioral rule that prevents the agent from prompting for unnecessary input. No critical guidance is missing.

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

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

The tool has zero parameters, so there is little parameter-specific semantics to add. The description reinforces the zero-input expectation by instructing the agent not to ask for a model ID first, which compensates for any potential ambiguity about required inputs.

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

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

Description names a specific verb (list/select) and resource (private RVC voice models), and clarifies the exact use case: choosing one of the user's private NiceVois-trained or uploaded RVC voices for conversion. This clearly distinguishes it from sibling tools like create_voice_conversion or list_training_jobs without needing to inspect schemas.

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

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

Explicitly states the condition for use: 'when the user wants to convert audio and you need to select one of their private NiceVois-trained or uploaded RVC voices.' It also gives a concrete behavior rule: do not ask for a model ID before calling. It lacks explicit when-not-to-use or alternative tool routing, but the clear trigger instruction 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?

Annotations already declare readOnlyHint/non-destructive, so safety is covered; the description adds the useful behavioral fact that this is a preview step whose output includes welcome-credit effect, shortfall, feasibility, and a balance-page link. It does not say whether the quote expires, is cached, or how it reacts to infeasible inputs, which keeps it below 5.

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

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

A single tightly packed sentence with the workflow trigger first and the payoff list second. Every clause carries information an agent needs; nothing is repeated from the title or schema.

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

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

An output schema exists, so the return list need not be spelled out, and the pre-job sequencing is well covered. However, with only 2 required inputs poorly documented and no mention of quote validity, failure modes, or how the quote relates to start_training, the definition is adequate but incomplete for a pricing-gate tool.

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

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

Schema description coverage is only 33% and the description adds nothing about durationSeconds or epochs — neither of which is documented in the schema either. The description mentions no parameter at all, leaving half the inputs uninterpreted, so it fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('quote an RVC training job') and enumerates what the quote contains (payable amount, balance, shortfall, feasibility), which clearly separates it from create_training_job and get_training_account. It stops short of naming the sibling it replaces, so a 4 rather than a 5.

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

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

'Call after inspecting the audio and before creating a job' gives a concrete position in the workflow and implies the alternative (skip the quote and call create_training_job at your own risk). It never names a sibling tool explicitly and gives no explicit exclusion cases, so it is clear context without full routing guidance.

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

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

Annotations already indicate write operation (readOnlyHint=false) and non-destructiveness. The description adds the context of starting training after upload, but does not disclose other behaviors like asynchronicity, potential long execution time, response format, or error conditions. It provides adequate but not rich behavioral context beyond annotations.

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

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

The description is a single sentence, which is concise, but it omits necessary parameter explanation and behavioral details. Conciseness is valued, but not at the cost of essential information. It could be slightly expanded without losing efficiency.

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 only one parameter and an output schema that is not described, the description should cover prerequisites (mentioned), response semantics (missing), error possibilities, and async behavior. The context of starting a training job implies possible long-running or queued execution, but no such detail is provided. The description is insufficient for complete understanding.

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 description coverage is 0%, so the description carries the full burden of explaining the only parameter (jobId). However, the description never explicitly states that jobId is the ID returned by create_training_job. It only implies this by referencing the upload URL from create_training_job. An agent would benefit from a clear statement like 'The jobId returned by create_training_job.' This omission fails to add 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 the verb ('Starts') and the resource ('the private cloud RVC training job'), distinguishing it from sibling tools like create_training_job (which prepares the job) and get_training_job (which checks status). It is specific and immediately informative.

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 says 'Use this only after the source audio was successfully PUT to the upload URL returned by create_training_job,' providing a clear precondition and referencing the correct sibling tool. This tells the agent exactly when and after what step to invoke this tool.

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