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

No annotations are provided, so the description carries the full burden. It does not disclose that by default the call blocks up to ~300s (watchdog timeouts possible), that async polling with check_task/download_result is required for long runs, or any prerequisite about the uploaded vocal audio. These behaviors are buried in schema field descriptions, not stated in the description.

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

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

A single, front-loaded sentence with no waste. Being terse is efficient, though it borders on under-specification given the tool's async 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?

For a 9-parameter audio-generation tool with an async polling workflow, no annotations, and no output schema, the description is far too thin. It omits the blocking-vs-async behavior, failure modes, and parameter semantics that 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 56%, leaving several parameters (title, filename, negativeTags, model) undocumented. The description adds no parameter meaning at all. With over a third of parameters uncovered and no compensating text, this is weak.

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 ('Add') and resource ('instrumental backing') with the input ('uploaded vocal audio') and provider ('Suno'). This is clear but does not differentiate it from the close sibling add_vocals, which is essentially the inverse operation.

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

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

There is no guidance on when to use this versus siblings like generate_music, add_vocals, or extend_music. The async workflow is described inside a parameter schema rather than in the description, and the description gives no context 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 the description carries the full behavioral burden, and it says nothing about blocking vs async execution, expected generation latency, credit consumption, or what files are produced. The only hints (wait, max_wait_seconds) live in the schema, not the description, and the far more complex async/polling workflow is never surfaced.

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

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

A single sentence with no filler is front-loaded and easy to scan, but it is under-specified rather than concise — the brevity comes at the cost of any operational context.

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

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

For a 10-parameter generation tool with an async polling mode, no annotations, and no output schema, a one-line description is not sufficient. An agent cannot infer the polling contract, output artifacts, or how the vocal models differ from what the schema alone provides.

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 50%, leaving model, style, title, filename, and negativeTags undocumented in both places. The description adds zero parameter meaning (no lyric/format hints for prompt, no model-selection advice), 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+resource combination ('Add AI vocals to uploaded instrumental audio') and names the underlying provider (Suno), which makes it distinguishable from the reverse-direction sibling add_instrumental. It does not explicitly name or route against alternatives, but the purpose is unambiguous.

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

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

The phrase 'uploaded instrumental audio' weakly implies a prerequisite that an instrumental already exists at a URL, but there is no explicit when-to-use guidance, no mention of when to prefer add_instrumental/cover_audio/generate_music, and no note on credit cost or eligibility.

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

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

Annotations are absent, so the description carries full burden. It does not disclose processing time, supported formats, failure modes, or the max file size (10MB is only in schema). Minimal behavioral insight.

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

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

Single 17-word sentence, front-loaded with key verb and resource. No wasted words.

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

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

For a simple input/output tool without output schema, the description is adequate but lacks context on quality, latency, or supported audio types. Could be more complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds no meaning beyond the schema (e.g., no extra context for audio_url, filename, or download_dir).

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 ('isolate'), resource ('audio'), and output ('clean isolated audio'), with specific reference to ElevenLabs via kie.ai. It distinguishes from siblings like 'separate_vocals' by mentioning 'background noise,' but does not explicitly differentiate.

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

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

No guidance on when to use this tool versus alternatives (e.g., separate_vocals). No when-not or prerequisites mentioned. The description only states the basic input/output flow.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the conversion action without mentioning whether it is read-only, has side effects, requires permissions, or handles errors, leaving key behavioral aspects unspecified.

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 prefixed by 'NEW —', which front-loads relevance. It contains no fluff, but could be slightly more structured for readability.

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

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

Given no output schema, the description fails to explain the output format or how the enhanced description is used, and does not integrate with sibling tools (e.g., generate_music) despite being a likely preprocessing step.

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%, but the description adds value by providing an example input ('Pop, Mysterious') and clarifying the transformation purpose, which goes beyond the schema's minimal description 'Concise style description to enhance'.

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 converts concise style input into an enhanced style description for music generation, using a specific verb ('Convert') and resource ('style input'), and distinguishes it from generation siblings.

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

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

The description implies usage as a preprocessing step for music generation tools (e.g., generate_music) with the example 'Pop, Mysterious', but does not explicitly state when to use it versus alternatives or provide when-not-to-use guidance.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the action without revealing whether the operation is read-only, whether it consumes credits, or what the response format looks like.

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, short sentence that directly states the tool's purpose with no extraneous words. It is optimally concise and front-loaded.

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

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

For a parameterless tool, the description covers the essential purpose. However, it lacks any mention of return values or format, which would help the agent interpret the result. Given the simplicity, it is mostly complete.

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

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

The input schema has zero parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter semantics, but this is adequate given the absence of 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 uses the specific verb 'check' and clearly identifies the resource as 'remaining kie.ai account credits'. Among sibling tools focused on generation and editing, this is the only credit-related tool, making its purpose unambiguous.

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

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

No usage guidelines are provided. The description does not indicate when to use this tool versus alternatives, nor does it mention any prerequisites or context for checking credits.

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

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

No annotations are provided, so the description must fully disclose behavior. It only states 'check status', omitting whether the tool is read-only, what the response contains, or any side effects. Minimal behavioral context.

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

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

A single sentence that is front-loaded and to the point, with no wasted words. Efficiently conveys the core action.

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 minimally adequate but lacks details on response content, error handling, or behavior under different task states. Enough to understand basic function 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 input schema has one string parameter (task_id) with 0% description coverage. The description mentions 'by taskId', adding context that task_id is the identifier, but does not explain format, origin, or examples. Some value added but insufficient for full compensation.

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

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

The description clearly states the verb 'check' and the resource 'status of a kie.ai generation task' with the mechanism 'by taskId'. It distinguishes itself from sibling tools like list_tasks, which lists tasks, and generate_*, which create 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 implies usage when you have a taskId and want to query its status, but provides no explicit guidance on when to use this tool versus alternatives like list_tasks (which might also show status) or 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?

No annotations are provided, so the description must disclose behavioral traits. It mentions the download path but does not disclose safety, destructiveness, or other important behaviors like blocking vs. async mode, rate limits, or permissions.

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, consisting of just two sentences that get straight to the point. No unnecessary 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 6 parameters and no output schema, the description does not explain the tool's behavior in sync vs async mode, return values, or how it interacts with other tools like check_task and download_result. This is insufficient for a tool that requires polling in async mode.

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 83%, so the schema already explains parameters well. The description adds no extra semantic value beyond what is in the schema, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Convert a Suno track to lossless WAV format') and provides the download location. However, it does not explicitly distinguish from other audio conversion tools among the siblings.

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

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

The description lacks any guidance on when to use this tool versus alternatives. No mention of prerequisites, context for conversion, or integration with other tools like check_task or download_result.

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 discloses almost nothing: it does not say the operation is asynchronous/blocking by default, that it consumes credits, that generation can take minutes, or what comes back. The single sentence gives only the creative intent, not the operational 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?

One compact, front-loaded sentence with no filler. It is efficient, though the extreme brevity is part of the tool's under-specification problem rather than a virtue.

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 generation tool with no annotations, no output schema, and only 54% parameter coverage, a single sentence is not enough. The async/polling workflow, credit cost, and result shape are all unaddressed at the description 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?

Schema coverage is only 54%, and the description adds nothing beyond loosely echoing three fields (vocals, style, instrumentation). It does not clarify the distinction between style, prompt, and negativeTags, what customMode does, or how model choice affects the cover.

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: create an AI cover from uploaded audio, with the field hints (vocals, style, instrumentation) and the backend (Suno). An agent can distinguish it from siblings like generate_music or add_vocals, but the description never names or contrasts those alternatives explicitly.

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

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

There is no guidance on when to choose a cover over generate_music, extend_music, or add_vocals, nor any stated prerequisites for the source audio. Usage is only implied by the name and the mention of 'uploaded audio'.

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

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

Description discloses the download destination (kie/assets/raw/), but without annotations, it fails to detail other behavioral traits like wait mode, error handling, or rate limits. Some transparency but significant gaps.

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

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

Two sentences, no filler, front-loaded with purpose. Highly concise.

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

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

With 8 parameters, 2 required, no output schema, and no annotations, the description is too brief. It does not explain the full workflow, return format, or dependencies on other tools like check_task.

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 high (88%), so description adds marginal value beyond the schema. It provides context for download_dir default but does not explain other parameters like author or domainName beyond their schema descriptions.

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

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

Description clearly states it generates an MP4 music video from a Suno track and specifies the download destination. However, it does not differentiate from sibling tools like generate_video, which could be ambiguous.

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

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

No guidance on when to use this tool versus alternatives like generate_video, or prerequisites such as needing a Suno generation task. 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?

No annotations are provided, so the description bears full burden. It mentions the combination of image and optional voice and the return of a characterId, but does not disclose side effects, error handling, limitations on image URLs, or 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 very concise, with three short, front-loaded sentences. No wasted words, but could be slightly more structured to separate purpose, behavior, and output.

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 4 parameters (2 required) and no output schema, the description is incomplete. It does not explain constraints on image URLs, how characterId is formatted, or how this tool fits into the video generation 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?

Schema description coverage is 100%, providing clear parameter descriptions. The tool description adds 'Combines image + optional voice' and 'Returns characterId', slightly extending schema info but not substantially.

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 ('Create'), the resource ('reusable visual character for Gemini Omni video generation'), and distinguishes from siblings like 'create_omni_voice' by specifying that it combines image with optional voice.

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 creating characters but does not explicitly state when to use this tool versus alternatives (e.g., generate_video) or provide prerequisites. Lack of exclusions limits guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool creates a reusable voice character and returns a kieAudioId, but fails to explain mutation implications, authorization needs, rate limits, or any side effects. The description is too brief to be fully transparent.

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

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

The description is extremely concise: two sentences covering purpose, newness, use case, and output. Every sentence adds value with no wasted words. Front-loaded with 'NEW' and the core action.

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 moderate complexity of creating a voice character, the description covers the essential purpose and output linkage. However, it omits details on customization behavior and validation beyond what the schema provides. Still, it is largely complete for a well-schematized 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 100%, so the schema already documents each parameter. The description adds no new parameter-level meaning beyond the schema. Baseline 3 is appropriate as the description does not need to compensate for coverage gaps.

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

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

The description clearly states the verb (create), resource (reusable voice character), and context (Gemini Omni video generation). It also specifies the return value linking to generate_video. However, it does not explicitly differentiate from sibling tools like create_voice_clone, which creates a different type of voice resource.

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 mentions a specific use case (video generation) and links to generate_video, but does not provide explicit guidance on when to use this tool versus alternatives such as create_voice_clone or prepare_voice_clone. No when-not or exclusion criteria are given.

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

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

No annotations exist, so the description carries the full burden. It highlights experimental status and unverified end-to-end flow but does not disclose what happens on failure, required permissions, or state changes beyond returning a voiceId.

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 at one sentence, front-loading key info (EXPERIMENTAL, STEP 2). Every word adds value without 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 8 parameters and no output schema, the description is somewhat sparse. It omits details like verification URL format, timeout behavior for max_wait_seconds, and failure handling, leaving gaps for the 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?

With 75% schema coverage, most parameters already have descriptions. The tool description adds no extra meaning beyond what's in the schema, so it meets the baseline but does not improve understanding.

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

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

The description clearly states it is the second step after prepare_voice_clone, requiring the verification recording. It specifies the outcome (voiceId) and usage context (generate_music), distinguishing it from siblings like prepare_voice_clone and regenerate_voice_clone.

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 (after prepare_voice_clone, after recording the verification phrase) but does not provide exclusions or alternatives for failure cases.

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

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

No annotations are provided, so the description carries the full burden. It does not mention error handling, authentication, or whether files are overwritten, leaving significant behavioral gaps.

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

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

A single, front-loaded sentence is concise with no wasted words. However, it may be too terse for important nuances.

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 3 parameters, no output schema, and zero annotations, the description is insufficient. It lacks details on return values, error cases, and workflow context among siblings.

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

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

Schema coverage is only 33% (only download_dir has a description). The description adds default directory info but does not explain task_id or filename, which are crucial but undocumented.

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

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

The description clearly states the action 'Download a completed task result' and the default target directory 'kie/assets/raw/', making the purpose apparent. However, it implies a fixed destination while the schema allows a custom directory, causing slight inconsistency.

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

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

No guidance on when to use this tool versus alternatives (e.g., upload_file) or prerequisites like task completion. The agent is left to infer usage context.

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

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

With no annotations, the description carries the full behavioral burden, yet it only states the audioId prerequisite. It says nothing about cost/credit consumption, async vs blocking execution, refund behavior on malformed input, or mutation scope — behavior that matters for a paid, stateful generation call.

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

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

Two tight sentences with the core action front-loaded and the prerequisite second. Nothing is wasted, though the minimal content reflects under-specification rather than meaningful economy.

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 an 11-parameter generator tool with no output schema and no annotations, the description is thin, omitting async/cost/refund context. The relatively rich per-parameter schema descriptions partially compensate, keeping this at the minimum-viable level rather than a 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 coverage is 73%, so most parameters are already documented in the schema (wait, prompt, download_dir, max_wait_seconds). The description adds only the audioId requirement, which the schema already conveys, so it does not meaningfully extend parameter semantics. Baseline 3 is appropriate.

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

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

States a specific verb (extend/continue) and resource (an existing Suno track) plus scoping detail (from a specific point). An agent can distinguish it from generate_music, but the description does not differentiate it from close siblings like replace_section or upload_extend_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?

Provides one prerequisite (audioId from a previous generate_music task), which implies when the tool is usable. It gives no explicit rule for choosing between this and replace_section, upload_extend_audio, or add_instrumental, leaving alternatives to inference.

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

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

With no annotations provided, the description carries full burden. It discloses only the 'one call per taskId' constraint, but fails to mention if the operation is destructive, what happens on repeated calls, authentication needs, or rate limits. The lack of behavioral context makes it risky for an AI 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 two sentences, fully front-loaded with purpose in the first sentence and a key constraint in the second. No wasted words; every sentence adds value.

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

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

For a tool with 3 parameters and no output schema, the description provides core purpose and a constraint, but omits expected output type, file format, or error handling. Given the absence of output schema, more detail on return values would help completeness.

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%, but the description adds important context: 'Auto-generated if omitted' for filename and a crucial warning about absolute directory paths for download_dir. 'One call per taskId' also relates to parameter usage, enhancing understanding 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 verb 'generate' and the specific resource 'album cover art image for an existing Suno music track'. It distinguishes from sibling tools like 'generate_image' (general image generation) and 'create_music_video' (video). The constraint 'One call per taskId only' further clarifies the 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 implies usage context (existing music track) and a constraint (one call per taskId), but does not explicitly state when to use this tool over alternatives like 'generate_image' or what prerequisites are needed. There is no guidance on 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?

No annotations are provided, so the description carries full burden. It mentions the download destination and the service used, but lacks details on side effects, cost, rate limits, or error behavior. The schema provides async mode details, but the description itself is minimal.

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

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

The description is two concise sentences, front-loaded with the action verb and resource. Every word 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?

The tool has 7 parameters and uses a complex async workflow, but the description is minimal. The schema compensates with thorough parameter documentation, yet the description does not cover return values or error handling. Adequate but not comprehensive.

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

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

Schema description coverage is 100%, so the schema already documents all parameters well. The description adds no extra meaning beyond noting the download directory, so a baseline of 3 is appropriate.

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

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

The description clearly states the tool generates multi-speaker dialogue, mentions the underlying service (ElevenLabs Text-to-Dialogue V3 via kie.ai), and indicates the output location. This distinguishes it from sibling tools like generate_tts (single speaker) and generate_music (audio generation).

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 says 'Great for conversations between characters,' implying a use case, but it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or constraints.

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

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

With no annotations, the description carries the full burden and does well: it discloses cost (~4.2 credits/min, cheaper than ElevenLabs), the quality-degradation risk on long flash takes, the output destination (kie/assets/raw/), and limited-time pricing expiry. It omits nothing critical, though it says nothing about auth/permissions or concurrency limits.

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 identity and the two operating modes, and the model tradeoffs are tightly packed. Some promotional phrasing ('cheaper than all ElevenLabs tiers', repeated pricing) consumes space without helping invocation, keeping it from a 5.

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

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

For a 12-parameter tool with no annotations and no output schema, the description covers mode routing, model tradeoffs, cost, and save location well. It leaves speaker_id/pacing semantics and the async polling flow to the schema, which is acceptable given 92% coverage.

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

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

Schema coverage is already 92%, so the schema documents nearly every parameter (model enums, wait, speakers, temperature). The description largely restates schema content (2-speaker cap, tone tags, enum meaning) rather than adding new semantic detail, which is the baseline-3 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?

States a specific verb+resource (native Gemini TTS via kie.ai) and enumerates the distinguishing capabilities: style-directed speech, 30 named voices, up to 2 speakers, inline tone tags. It never names sibling tools like generate_tts or generate_dialogue, so the agent must infer the boundary rather than being routed explicitly.

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 clear mode selection rules (simple mode = text+voice_name; dialogue mode = speakers+dialogue_turns) and model selection guidance keyed to clip length (flash for ~60s expressive takes, pro for stable multi-minute narration). However, it offers no when-not-to-use this tool versus the sibling TTS/dialogue tools.

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

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

With no annotations, the description carries the full burden and does disclose real behavioral traits: output goes to kie/assets/raw/, per-model credit costs (3cr to 100cr), latency (~4s for nano-banana-2-lite), and quality tiers. It stops short of covering auth/permission needs, failure modes, or what happens when a model rejects an aspect_ratio, so it is strong but not exhaustive.

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

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

The purpose and profile_brief tip are correctly front-loaded, but the body becomes a dense catalog of ~15 model IDs and prices in one paragraph, which is hard to scan and near the limit of what belongs in a tool description rather than a referenced resource. Information density is high, but structure suffers.

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

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

For a 9-parameter, no-output-schema tool this covers most of what an agent needs: output location, model selection guidance, and async handling is already documented in the schema's `wait` parameter. It lacks guidance on parameter interactions (e.g. aspect_ratio validity per model beyond a pointer) but is otherwise complete.

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

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

Schema description coverage is 100%, so the baseline is 3, but the model guide meaningfully enriches the `model` parameter by mapping use-cases (blueprints, text/logos, anime, upscale, BG removal) to concrete model IDs and their tradeoffs. The remaining parameters get no semantic help in the description, so it does not reach 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 opening sentence gives a specific verb and resource ('Generate an image using kie.ai') and the surrounding model guide makes it immediately distinguishable from siblings like generate_video, grok_image_edit, and seedream_layer_decompose, each of which is explicitly redirected to. An agent can tell what this tool is and is not without opening the schema.

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

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

Explicit routing rules are given: call profile_brief first for architecture/game-art/advertising/product-UI, use list_models filter="use-case" to explore, and delegating alternatives named for layer splitting, region refine, and editing. When-to-use and when-to-use-something-else are both stated.

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

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

No annotations provided, so description must disclose all behavioral traits. Mentions output is text, no file download, and max 200 characters. Adequate but lacks details like rate limits, API key requirements, or whether generation is synchronous.

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

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

Two sentences, no fluff. Every word is meaningful.

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 single-parameter tool without output schema or annotations, the description sufficiently covers purpose, input constraints, and output type. Could mention that prompt should be lyrics-style or something, but not necessary.

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 description for prompt. Tool description reinforces the max length constraint but adds no new semantic information beyond what schema provides. Baseline score is appropriate.

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

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

States it generates song lyrics from a prompt using Suno AI, which is specific. Does not explicitly differentiate from siblings like generate_music, but the resource 'lyrics' implies a distinct purpose.

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

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

No when-to-use or when-not-to-use guidance. Does not mention alternatives among the many sibling tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses only that a new track is produced; it says nothing about credit consumption, whether the source tracks are preserved, or the blocking/async default behavior referenced only inside the schema.

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

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

Two short sentences, front-loaded with the core action and the required input. The 'NEW —' marker is minor noise, and otherwise every phrase 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 an 8-parameter generative tool with no output schema and no annotations, this is thin. Missing are the cost/credit implications, model-version tradeoffs, and any hint of the async workflow, all of which an agent needs before invoking it.

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

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

Schema coverage is 75%, so most parameters are already documented in the schema (including the detailed wait/polling and download_dir notes). The description adds one genuinely useful semantic: audioIds must come from previous generations. Beyond that it adds nothing over the structured fields.

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

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

States a specific verb (mashup) and resource (up to 2 Suno tracks into one new track), which an agent can distinguish from sibling generation tools. However, it never contrasts itself with the closest siblings (extend_music, cover_audio, add_instrumental), so differentiation is left to inference.

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

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

The clause 'Provide audioIds from previous generations' gives one prerequisite (source audio must already exist), which is useful. But there is no guidance on when to mashup versus extending, covering, or layering a track, and no exclusions or alternative routing.

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

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

Discloses async behavior and download directory, but no annotations are provided. Missing details on file conflicts, naming, or authentication requirements, which would be needed for full transparency.

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

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

Two sentences, front-loaded with the main purpose. Efficient but could be slightly more structured with bullet points for parameters.

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

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

Covers core functionality and async mode but does not describe return values or error scenarios. Adequate for a simple export tool given no 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 coverage is 83%, and the description adds context for the wait parameter and directory, but most parameter meaning is already clear from the schema. Adds marginal value.

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

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

The description clearly states 'Export a Suno track to MIDI notation' and specifies the output location, distinguishing it from sibling tools like generate_music or download_result.

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

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

No explicit guidance on when to use this tool versus alternatives, such as other export tools or polling mechanisms. The async mode hint is present but not contextualized.

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 does disclose the key behavior: it 'polls until done and downloads to kie/assets/raw/'. However, it omits cost/credit implications, failure behavior, and the blocking-vs-async tradeoff (that detail lives only in the schema's wait param). Useful but incomplete for a paid, long-running generation call.

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?

Short, front-loaded sentences with the core action stated first and useful details following; every clause adds something. Slightly listy but 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?

No output schema exists, but the schema is fully documented and the description covers backend, model range, duration, purpose, and the polling/download destination, which is sufficient for an agent to invoke and interpret 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?

Schema description coverage is 100%, so the schema already documents all 9 parameters, setting the baseline at 3. The description adds only duration ('up to 8 minutes') and model tier hints that largely duplicate the model enum descriptions, so it does not meaningfully extend parameter semantics.

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

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

States a specific verb and resource ('Generate music using Suno via kie.ai') and adds scope details (model range, up to 8 minutes) plus use cases (game music, ambient, jingles). It clearly separates itself from generative siblings like generate_sfx or generate_tts, though it never names an alternative explicitly.

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?

Use cases ('great for game music stems, ambient tracks, and jingles') imply when this is appropriate, but there is no explicit routing against siblings such as extend_music, cover_audio, add_vocals, or generate_sfx, and no exclusions or prerequisites are given. Usage is inferable rather than stated.

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

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

With no annotations, description must disclose behavioral traits. It mentions 'reusable music character' and the prerequisite, but does not state side effects, auth needs, or what happens to the existing track. Minimal insight beyond basic action.

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

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

Extremely concise – two sentences. Front-loaded with 'NEW' to indicate freshness. No fluff; 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?

Description is functional but omits broader context: what a Suno Persona is, how to use it post-creation, or what the API returns. Given 7 parameters and no output schema, more context would aid completeness.

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% (all parameters described). Description adds no extra meaning beyond the schema, e.g., the prerequisite is already in taskId description. 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?

Explicitly states it creates a Suno Persona from an existing Suno track, with specific verb and resource. Clearly distinguishes from sibling generation tools like generate_music or cover_audio by focusing on persona creation.

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

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

Provides a clear prerequisite (taskId from V3.6+ generation) but lacks guidance on when to use persona creation versus alternatives like cover_audio or generate_music. No explicit when-not or comparison to 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?

Discloses the underlying model (Suno V5) and removal of ElevenLabs model, mentions output directory (kie/assets/raw/), and via parameter descriptions explains async mode. However, with no annotations, the description does not fully cover safety, permissions, or guarantees. Provides some behavioral context but not comprehensive.

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?

Extremely concise: three sentences. Front-loaded with core action, followed by examples and a sibling distinction. 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?

Describes model, use case, and alternative, but omits the return value/format (no output schema). While parameter descriptions explain async polling, the description lacks an overall picture of what the agent receives upon completion.

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 detailed parameter descriptions. The description adds value by suggesting use cases (game sounds) and directing to alternatives, but does not significantly augment the schema's per-parameter meaning.

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

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

Clearly states it generates a sound effect from text via Suno V5, with specific examples (game sounds: UI clicks, magic spells, etc.). Explicitly distinguishes from sibling generate_sounds for loop/BPM/key control.

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

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

Provides a clear when-to-use scenario (game sounds) and an explicit alternative (generate_sounds for loop/BPM/key control). However, lacks guidance on when not to use compared to other sound generation siblings (e.g., generate_tts, generate_dialogue).

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 adds one genuine behavioral fact — results are downloaded to kie/assets/raw/ — but that destination is already stated in the download_dir schema description, so the marginal value is small. It does not disclose the blocking/async behavior, cost, or failure handling that a generation tool should surface.

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

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

Two short sentences, front-loaded with the action and resource, followed by the output location. No filler or redundancy; every clause carries information.

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

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

For a 10-parameter tool with no annotations and no output schema, the description is only marginally sufficient. It covers purpose, three parameters, and the save destination, but omits sibling differentiation, model-selection guidance, and any behavioral context an agent would want before invoking a long-running generated-audio call.

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

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

Schema description coverage is 70%, above the midpoint, so the schema already documents prompt, soundKey, soundLoop, soundTempo, wait, download_dir, and max_wait_seconds. The description's mention of BPM, key, and loop control echoes those fields without adding syntax or constraints. Params like model, filename, and grabLyrics remain undocumented in both places, but the baseline 3 is appropriate given the schema does most of the work.

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 ("Generate loopable sound effects") plus the provider (Suno) and three controllable dimensions (BPM, key, loop). This is more than a restatement of the name. However, it does not distinguish itself from the very similar sibling generate_sfx (and generate_music), so an agent cannot tell which to pick from the description alone.

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

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

There is no when-to-use or when-not-to-use guidance. With generate_sfx and generate_music in the sibling set, the agent gets no signal about when this loop-oriented sound tool is preferred over those alternatives. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It discloses model variants, async behavior, download location constraints, and voice_id limitations (curated set, rejection of arbitrary IDs). However, it does not explicitly state side effects (file creation) or auth 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?

Two sentences that pack essential information with no redundancy. First sentence establishes core purpose and key differentiators; front-loaded for quick comprehension.

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 9 parameters and no output schema, the description covers models, async mode, and file location well. Missing details on return value (e.g., file path vs task ID) and output file format (e.g., .mp3). Adequate but not exhaustive.

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 100% schema coverage, the description adds significant value beyond the schema: explains wait rationale, voice_id caveats, download_dir absolute path requirement, and model selection advice. Each parameter gets meaningful context.

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 'Generate speech from text', identifies the technology stack (ElevenLabs via kie.ai), and specifies output destination. This distinguishes it well from sibling tools like generate_music and generate_sfx.

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 some usage context (model selection, async mode via wait parameter) but lacks explicit guidance on when to prefer this tool over alternatives like generate_gemini_tts. No comparative analysis with sibling tools.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses per-second credit pricing, which models include audio, a documented failure mode ('Veo I2V intermittently fails its audio pass without one'), and a hard precondition (images must be uploaded via upload_file with real Content-Type). It doesn't cover error handling or what wait=true actually returns, so it stops 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?

The purpose is front-loaded, but the remainder is a single dense wall of arrow-delimited routing text rather than scannable structure. Most sentences carry model-selection value, though the volume partly overlaps with what list_models exists to provide.

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

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

For a 9-parameter tool with nested model_options and no output schema, the description covers the essentials: destination directory, model-selection guidance, upload prerequisite, and failure caveats. It leaves minor gaps around the blocking-mode return value, but nothing that would cause a wrong invocation.

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

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

Schema coverage is 100%, so the baseline is 3, but the guide adds real meaning to the `model` parameter that the schema's one-line example cannot (which model fits which use case and cost). It also enriches `image_urls` by mandating upload_file, going beyond the schema's bare 'Input image URLs'.

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

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

The opening sentence states a specific verb and resource ('Generate a video'), the backend (kie.ai, 85+ models), and the output location (kie/assets/raw/). It also explicitly routes adjacent work elsewhere ('Extend video→use veo_extend or runway_extend tools'), so an agent can separate it from the extend/upscale siblings 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?

The MODEL GUIDE is effectively a when-to-use decision tree: cinematic, budget, fast, lip-sync, avatar, motion control, multi-shot, and image-to-video each map to named models. It names alternatives and their selection conditions (e.g. 'Extend video→use veo_extend'), and points to list_models for exploration.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states what the tool returns (timestamped lyrics) but does not mention side effects, idempotency, network calls, or any caveats. For a tool that likely performs an API fetch, the description lacks necessary behavioral transparency.

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: one short sentence plus a 'NEW' prefix. It is front-loaded with the core functionality and uses, wasting no words. Every part 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 no output schema, the description should compensate by explaining the return format (e.g., structure of timestamped words). It mentions use cases but omits what the agent will actually receive. For a simple 2-param tool, the missing output details reduce completeness.

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% (both parameters have meaningful descriptions like 'Suno task ID' and 'Audio ID from sunoData'). The description adds no additional parameter information beyond the schema, so it meets the 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?

The description clearly states the tool's function: 'Get word-level timestamped lyrics from a Suno track.' It uses a specific verb ('Get'), specifies the resource ('word-level timestamped lyrics'), and names the source ('Suno track'). This distinguishes it from siblings like 'generate_lyrics' (which creates lyrics) and 'speech_to_text' (which transcribes audio), though it does not explicitly contrast them.

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

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

The description provides context for when to use the tool: 'Useful for karaoke, captioning, or sync.' However, it does not offer guidance on when not to use it or mention alternative tools. Given the large set of sibling tools, explicit exclusions or comparisons would improve this dimension.

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 and does much of it: it states the credit cost (4), the dependency chain on grok_segment_map, chaining semantics for returned task_ids, and the file download location. It does not cover auth requirements, rate limits, or failure behavior, leaving modest gaps for a zero-annotation mutation tool.

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

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

Front-loaded with action, cost, and the two modes as numbered branches; each sentence carries routing or behavioral payload. Density is justified by the two-mode complexity and nothing is wasted.

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

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

With no output schema, the description compensates by describing the return (a new full image) and how returned task_ids chain into further segment/edit calls. It covers both modes and the prerequisite tool, but could say more about failure modes or what happens when neither mode's parameters are supplied.

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 every parameter, including mutual exclusivity and the aspect_ratio default. The description adds mode-grouping context that helps interpret the parameters together, but no format or syntax detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb+resource ('Edit an image with Grok Imagine Image 2.0') and explicitly enumerates its two operating modes with the parameters that select each. An agent can distinguish it from siblings like grok_segment_map or generate_image 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?

Explicitly prescribes when to use each mode (region mode = task_id + mask_indexs; whole-image mode = image_urls + aspect_ratio + prompt) and gives an ordering dependency, instructing the agent to run grok_segment_map first and pick regions by NAME. This is a routing-quality guideline, not just context.

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

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

No annotations are present, but the description discloses key behaviors: it returns region index, semantic name, and mask PNG URL, and notes it is free. This adds useful context beyond the bare 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?

The description is slightly verbose but well-structured, covering purpose, usage, output, and cost in a logical flow. It is not excessively redundant and remains readable.

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

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

Given only one parameter and a clear schema, the description sufficiently explains the tool's role in the workflow, its input constraints, and its output format, making it complete for an agent to decide when and how to use it.

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

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

The schema already describes the task_id parameter in full (Task ID from a completed generate_image call with model grok-imagine-image-2-0/text-to-image). The description mainly repeats this requirement without adding new parameter-specific semantics.

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

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

Explicitly states the tool segments a Grok Imagine Image 2.0 generation into named regions for targeted editing, with a clear verb and resource. It is distinct from sibling tools like generate_image and grok_image_edit.

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 usage conditions: only works on task_ids from a Grok Image 2.0 generation, and outlines a recommended workflow (generate_image -> grok_segment_map -> grok_image_edit).

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

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

No annotations provided, so description carries full burden. It clearly states the action (list) and output content (models with options). No mention of pagination or rate limits, but for a read-only list tool, this is sufficient and not misleading.

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

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

Single sentence that conveys purpose. It is concise but could be slightly more structured (e.g., mentioning that it returns a list). No wasted words, but could include more 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?

No output schema exists, so description should clarify return structure. It mentions 'aspect ratios and model-specific options', which gives a hint but not full details. For a simple list tool, it is adequate but not thorough.

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

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

Schema description coverage is 100% (both parameters are described). The description does not add new meaning beyond the schema; it echoes 'aspect ratios and options' which aligns with parameter 'verbose'. 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 lists all available kie.ai models and includes aspect ratios and options. It distinguishes from sibling tools like list_tasks and check_credits by focusing on models.

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

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

No explicit guidance on when to use this tool versus alternatives. Usage is implied (e.g., before generation), but no conditions or exclusions are provided. Sibling tools are diverse, so guidance would be helpful.

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 implies a read-only, non-destructive operation. However, it does not disclose details like permissions required, behavior when the directory is empty, or if any filtering is applied.

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

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

Single sentence, no redundancy, front-loads key information. Every word serves a purpose.

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

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

Given no output schema, the description should explain return format. It mentions 'list all files' but not the output structure (e.g., strings, objects). For a simple tool with no params, it is adequate but incomplete for a full 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?

There are zero parameters, so the description's job is minimal. Baseline is 4. The description adds no extra meaning beyond the schema, but no value is needed.

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

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

The description clearly states the action ('List all files'), the target resource ('in kie/assets/raw/'), and the context ('waiting to be processed'). It distinguishes from sibling 'list_tasks' by specifying a directory and state.

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

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

The description lacks explicit guidance on when to use this tool versus alternatives. No mention of prerequisites, exclusion criteria, or comparison with sibling tools like 'list_tasks'.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions listing recent tasks from the session, but does not clarify what 'recent' means, the nature of the session, or whether the operation has any side effects (though likely read-only). Minimal transparency.

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 extraneous information. It is front-loaded with the verb and resource, making it easy to scan.

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

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

For a simple list tool with one parameter and no output schema, the description is minimally adequate but missing parameter explanation and clarification of 'recent' and 'session'. It does not reference return format or pagination. Given the simplicity, a score of 3 is appropriate.

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

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

The description does not mention the 'limit' parameter at all. With 0% schema description coverage, the agent has no additional context about what the limit does or how it affects results beyond the schema default of 10.

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 'recent image generation tasks from this session'. It distinguishes from siblings like 'check_task' (which likely checks a single task) and various generation tools by specifying the scope of recent session 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?

No explicit guidance on when to use this tool versus alternatives like 'check_task'. The description implies it is for listing, but does not state when not to use it or what to do if you need a different perspective.

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 behavioral disclosure: it notes the tool is experimental (#20), the two-phase process (submit + callback), and caveats about the completion step not being verified end-to-end and requiring a real callback URL. This is thorough for a tool with no annotations.

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

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

The description is three sentences with no wasted words. It front-loads the tool's identity (experimental, step 1, free) and efficiently covers the process, warnings, and limitations.

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 (6 parameters, no output schema), the description explains the workflow and key risks adequately. It could detail error scenarios or return values, but for a step-1 tool, the provided information is sufficient 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?

Schema coverage is 83%, so baseline is 3. The description adds context beyond schema by explaining the polling behavior for 'wait' and 'max_wait_seconds', and the callback server expectation. It does not detail each parameter but provides workflow context that aids usage.

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

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

The description clearly states it is 'STEP 1 of Suno custom-voice cloning' and describes the action: submit a clean vocal sample, poll to wait_validating, and trigger a callback. It distinguishes from its sibling 'create_voice_clone' which is the next step.

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 marks the tool as step 1 and directs to use 'create_voice_clone' afterward. It includes a warning about only cloning owned voices. However, it lacks explicit 'when not to use' or alternative tools for other cases.

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

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

No annotations are provided, so the description carries the full burden. It discloses what is returned, that costs are live, that the profile auto-infers from `request`, and that zero-arg calls enumerate profiles — enough to imply a read-only, advisory tool. It stops short of explicitly stating there are no side effects or that the brief is a snapshot versus a live fetch, so a small gap remains.

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

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

Front-loaded with the core purpose and the when-to-call rule in the first two sentences; every sentence earns its place. The long parenthetical enumeration of verticals is the bulkiest part — useful scope information, but it bloats the text and could be trimmed.

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

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

For a read-only advisory tool with two fully documented optional params and no output schema, the description covers purpose, trigger condition, degenerate call, and return contents. Nothing critical is missing, though the absence of any note on whether the brief is cached or live keeps it short of complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it confirms that omitting everything lists profiles and that `request` drives auto-inference and is echoed back so intake can be filtered. That interaction semantics goes beyond the schema's field text.

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 ('Get') and a specific resource (a vertical playbook) and then enumerates exactly what that playbook contains: intake questions, model routing with live costs, per-model prompt formulas, multi-tool workflows. The vertical coverage list nails the scope, and it is clearly distinguishable from every sibling, which are all generation/listing 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 gives explicit ordering guidance ('Call this FIRST when the user's request belongs to a known vertical'), an explicit degenerate call ('Call with no args to list available profiles'), and a follow-up workflow ('ask the user only the unanswered intake questions, conversationally'). An agent knows precisely when to reach for this instead of going straight to generate_image/generate_video.

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 bears full responsibility but only notes it's experimental (version #20) and does not disclose side effects, such as whether retrying overwrites previous results or the nature of the response.

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, front-loading the experimental nature and core action with no wasted words.

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

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

For a simple tool with one parameter and no output schema, the description covers the purpose and parameter but omits details about return value, idempotency, or what happens on retry.

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

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

Schema coverage is 100%, so baseline is 3. The description adds the qualifier 'failed/incomplete' to the parameter, providing marginal extra meaning beyond the schema.

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

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

The description clearly states the verb 'retry' and the resource 'custom-voice task', specifies it is for failed/incomplete tasks, and distinguishes it from sibling tools like create_voice_clone and prepare_voice_clone.

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

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

The description implies usage when a custom-voice task failed or is incomplete, but does not explicitly state when not to use it or mention alternative tools for similar purposes.

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 full burden for behavioral disclosure. It only states the basic operation ('replace a time range') without revealing side effects (e.g., whether the original track is modified, whether replacement is permanent, or any authentication or rate-limit considerations).

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-formed sentence that front-loads the core purpose. However, it could be slightly restructured to mention key parameters or usage notes without adding verbosity, so it earns a 4 rather than a 5.

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

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

Given the complexity of the tool (13 parameters, 5 required, no output schema, no annotations), the one-sentence description is insufficient. It does not explain return values, error states, or how the replacement process works (e.g., whether the rest of the track is preserved).

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 no additional meaning beyond the input schema. While schema description coverage is 69%, meaning some parameters are partly documented in the schema, the tool description itself does not explain the purpose or relationships of the parameters (e.g., how 'infillStartS' and 'infillEndS' define the target range).

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

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

The description uses a specific verb ('Replace'), names the resource ('a time range in a Suno track'), and specifies the action ('with new AI-generated content'). It clearly distinguishes this tool from siblings like 'extend_music' or 'cover_audio' which modify the full track or add sections rather than replace a segment.

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, nor any exclusions or prerequisites. For example, it does not mention that the original track must exist or that replacement may require specific credits.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states the purpose without mentioning whether the operation is destructive, requires authorization, has rate limits, or any side effects. Minimal transparency for a mutation tool.

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

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

The description is a single, well-formed sentence with no extraneous words. It is front-loaded with the action and resource. Could be slightly more informative but remains concise and clear.

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 5 parameters, no output schema, and sibling tools for other platforms, the description is incomplete. It lacks details on return values, error handling, or differentiation from similar extension tools like veo_extend. More information is needed for an agent to use it correctly without confusion.

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

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

The input schema already describes most parameters (prompt, task_id, quality, download_dir) with coverage estimated at 60%. The description adds no additional meaning beyond what the schema provides. For filename, the schema lacks description, but the description does not compensate. Baseline of 3 is appropriate given moderate 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 extends an existing Runway Aleph video with continuation content, specifying the verb (extend) and resource (existing video). It distinguishes from sibling tools like generate_video (creation) and veo_extend (Veo platform).

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description implies usage only for extending existing Runway Aleph videos but does not mention alternatives or exclusions. The context of sibling tools helps, but the description itself lacks explicit guidelines.

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

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

With no annotations, the description carries the full burden and does well: it discloses the per-output-layer credit model, the exact flash-vs-pro cost tradeoff, the 12-layer/38.9 cr failure mode of promptless flash, and the download destination (kie/assets/raw/). It omits call mechanics an agent needs, such as whether this is synchronous or returns a task id for check_task, and whether existing files are overwritten.

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 action and cost, then tiers, then input/output mechanics. It is a dense single paragraph with heavy billing detail, but each clause carries operational information rather than filler.

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

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

Seven parameters are all covered and the cost model plus download location are explained, which matters since there is no output schema. The remaining gap is execution semantics (sync vs task-based, failure behavior), which an agent would need for a multi-credit generative call.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates the tier/size pricing and the <bbox> tag syntax already present in the schema's prompt description; its only additive detail is the '-2, -3...' filename suffix convention, which is marginal.

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: 'Split ANY image into independent layers with Seedream 5.0'. That is unambiguous and distinct from every sibling tool (audio, video, TTS, upscaling), so an agent can route to it without opening the schema.

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

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

It gives real routing guidance: local files must go through upload_file first, prompt is required for tier=pro but optional for tier=flash, and omitting the prompt on flash causes unbounded layer counts. It doesn't state hard exclusions (e.g. no video input), so it falls just short of a full when/when-not matrix.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose that output lands in kie/assets/raw/, which is genuine context, but it omits the long-running/async nature, polling expectations, and whether the source audio is altered. The schema covers wait/poll behavior, but the description adds only the output-location detail.

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

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

Two short sentences, front-loaded with the core operation. The trailing fragment 'Downloads to kie/assets/raw/.' is terse but useful; overall there is essentially no wasted text.

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

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

For a 7-parameter, no-annotation, no-output-schema tool, the description is thin: it never explains what the caller receives or references the check_task/download_result polling flow. The schema picks up most of the slack on parameters, but the description leaves behavioral and post-invocation context incomplete.

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 86%, well above the high-coverage threshold, so the schema already documents type, wait, download_dir, and max_wait_seconds thoroughly. The description adds no parameter-level detail beyond restating that files go to the default raw directory, so baseline 3 is appropriate.

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

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

States specific verbs and resources: separating vocals from instrumentals or splitting into individual stems. It's clear what the tool does, but it never differentiates itself from the nearby sibling 'audio_isolation' or 'convert_to_wav', which an agent could easily confuse for the same job.

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 tells you the two modes exist but gives no guidance on when to choose this over adjacent tools like audio_isolation. The mode distinctions it does mention (separate vocal vs split stems) are already spelled out in the type enum description, so no routing value is added.

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 for behavioral disclosure. It mentions supported features (diarization, audio event tagging) but omits important details: required authentication, limits on audio length or file size, latency, and whether the operation is destructive or read-only. The description provides moderate transparency but lacks 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 two sentences long, entirely front-loaded with the core purpose. Every sentence adds value: first states the action and model, second lists supported features and output. 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?

Given no output schema and no annotations, the description covers the main purpose and supported features. However, it lacks details on output format (e.g., structure of transcription text, timestamps), error handling, and constraints (e.g., audio length, supported languages). It is fairly complete for a straightforward transcription tool but could be richer.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions diarization and audio event tagging, which correspond to boolean parameters, adding slight context. However, it does not elaborate on parameter formats, defaults, or interactions beyond what the schema already provides.

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

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

The description clearly states the verb 'Transcribe' and the resource 'audio to text', specifying the model (ElevenLabs Scribe v1) and key features (diarization, audio event tagging). It effectively distinguishes this tool from sibling tools like audio_isolation or generate_tts.

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

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

No guidance is provided on when to use this tool versus alternatives such as audio_isolation or separate_vocals. The description does not mention any prerequisites, constraints, or use cases, leaving the AI agent without decision-making context.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about this being an asynchronous task submission, expected generation latency, polling/retrieval flow, or failure modes. The async/polling behavior only appears incidentally inside parameter descriptions (wait, max_wait_seconds), not in the tool description.

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

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

Two short sentences, front-loaded with the differentiator and immediately followed by the alternative. 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 an 11-parameter, no-annotation, no-output-schema tool, the description covers only differentiation. Schema parameter text compensates for the async flow, but the description leaves the agent without any hint of the required-vs-optional reality of continueAt or the long-running nature of the call.

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

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

With 11 parameters and only 64% schema description coverage, several inputs (model, title, filename, instrumental) have no description anywhere. The tool description contributes no parameter meaning at all — notably it never mentions that continueAt is effectively required and must fall inside the upload's duration.

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 (extend) and resource (uploaded audio, explicitly not a Suno track), and names the sibling it is not — extend_music — so an agent can route without opening either schema.

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

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

Explicitly gives both the when (uploaded audio) and the when-not (Suno tracks) plus the alternative tool to use in that case. Routing is fully determined.

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 discloses important behavior: files expire after 3 days, image files are named by real magic-byte format rather than extension, Content-Type follows the name, and Veo I2V rejects mismatches. This is rich operational context beyond the schema.

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

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

The description is front-loaded with purpose and stays dense without obvious filler. It is slightly run-on and could be structured more clearly, but every sentence contributes relevant information.

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

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

Given no output schema and no annotations, the description covers what matters for correct invocation: return value, expiry behavior, naming/Content-Type caveats, intended usage, and parameter preference. The fully documented schema covers the remaining parameter details.

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

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

Schema description coverage is 100%, so the schema already documents every parameter in detail. The description only restates the preference for file_path over other input methods, adding little meaning beyond what the schema provides.

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

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

The description states a specific verb and resource: upload a file to kie.ai and get a public URL back. It distinguishes itself from generation siblings by framing itself as a preparatory upload utility used before passing files to generation 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 clearly says to use this before passing local images/audio/video to generation tools and explicitly prefers file_path for local files, which routes the agent among input parameters. It does not mention when not to use it or name a sibling upload alternative such as upload_extend_audio.

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

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

No annotations provided, and the description does not disclose behavioral traits such as whether the original video is modified, permissions needed, output format, or error handling. The description carries full burden and fails to inform.

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 clear front-loaded purpose. No extraneous content. However, key information is missing, reducing the value of conciseness.

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, no annotations, and moderate complexity (6 params, many siblings), the description is incomplete. It lacks details on expected output, duration, effect on original, and error scenarios.

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 67% (4 of 6 parameters described in schema). The description adds no additional parameter context beyond the prerequisite. It does not explain the meaning of 'prompt', 'model', 'seeds', 'filename', or 'download_dir' in relation to the extension process.

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 extends an existing Veo 3.1 video with additional content, specifying the prerequisite (taskId). It distinguishes from generation tools but does not explicitly differentiate from other extension tools like runway_extend.

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?

Only mentions the prerequisite of having a taskId from a previous Veo generation. No guidance on when to use this tool over alternatives (e.g., generate_video, runway_extend) or 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?

No annotations are provided. The description only states the action and prerequisite without disclosing behavioral traits like whether it is destructive, rate limits, or side effects. Carries minimal burden for transparency.

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

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

Single sentence that is short and to the point, containing no wasted words.

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

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

The description explains the purpose and prerequisite, but lacks details on output/return values and behavioral impact. Suitable for a simple tool but still incomplete given no annotations or output schema.

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

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

Schema coverage is 75%. The description adds the context that the task must be completed, which is not in the schema. For other parameters, it adds no additional meaning beyond the schema descriptions.

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

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

The description clearly states the action (upscale), the target (Veo 3.1 video), the resolution (1080p), and a prerequisite (taskId from completed generation). It distinguishes from sibling tools like veo_upscale_4k.

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 requires a task ID from a completed Veo generation, providing clear context for when to use. However, it does not explicitly contrast with veo_upscale_4k or mention when not to use.

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 mentions the operation takes 5-10 minutes and requires a prerequisite taskId, providing some transparency about latency and dependency. However, it does not disclose potential side effects, authorization needs, or result format, leaving gaps.

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

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

The description is extremely concise, consisting of two sentences that deliver the core purpose, time expectation, and prerequisite. Every word serves a purpose 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 has four parameters and no output schema, the description is incomplete. It does not explain how to handle the output (e.g., where the upscaled video is saved) or the role of parameters like 'index' and 'download_dir'. While the purpose and prerequisite are clear, additional context about workflow integration is missing.

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

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

The schema coverage is 75% (three of four parameters have descriptions), but the tool description adds no new information about how to use the parameters. For example, 'filename' lacks a schema description and is not explained in the description. The description does not compensate for missing parameter details, so value beyond schema is minimal.

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 upsamples a Veo 3.1 video to 4K resolution, distinguishing it from the sibling 'veo_upscale_1080p' which targets a different resolution. The verb 'Upscale' and resource 'Veo 3.1 video to 4K' are specific and actionable.

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

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

The description provides a prerequisite ('Requires taskId from completed Veo generation') and a time estimate, implying it should be used after a Veo generation. However, it does not explicitly contrast with alternatives like 'veo_upscale_1080p' or state when not to use this tool. The usage context is clear but lacks exclusion guidance.

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