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 adds almost nothing beyond the provider name. It does not state that this is a paid generation consuming credits, does not mention sync-vs-async behavior, output artifacts, or any permissions/API-key requirements — all operational detail lives in the schema parameter descriptions rather than 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?

A single front-loaded sentence with no filler, which is good structure. It is arguably too terse for an 11-parameter generation tool with no annotations, but nothing in it 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?

For a paid, multi-parameter generation tool with no annotations and no output schema, the description is incomplete: an agent gets no sense of cost implications, blocking vs. async behavior, or what is returned. The schema fills some of this gap, but the description itself leaves the operational picture mostly unstated.

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

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

With 11 parameters at 64% schema coverage, the description contributes zero parameter meaning — it never mentions tags, model, negativeTags, title, filename, or the wait/estimate_only controls. The schema documents several key fields, but the undocumented ones (model, negativeTags, title, filename) are left unexplained in both places.

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

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

The description states a specific verb+resource ("Add instrumental backing"), names the required input (uploaded vocal audio) and the provider (Suno). An agent can distinguish this from generate_music, but it never explicitly contrasts itself with the obvious mirror sibling add_vocals, so it stops short of a 5.

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

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

The precondition is implied — you must already have uploaded vocal audio, which is why uploadUrl is the only required field. However, there is no explicit when-to-use/when-not guidance and no pointer to alternatives like add_vocals, generate_music, or cover_audio, so the agent must infer routing from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and one sentence does not cover it. It never mentions credit consumption, that this is a long-running generation with an async option, or any prerequisite on the uploaded audio; the schema's wait/max_credits/estimate_only fields partially fill the gap but the description adds almost nothing.

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

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

A single front-loaded sentence with zero wasted words. It is tight and readable, though for a 12-parameter generation tool it is arguably undersized rather than optimally scoped.

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 12 parameters, no annotations, and no output schema, an agent needs more: the uploadUrl prerequisite, the credit/cost model, and the async submit-then-poll workflow are all omitted. The description is not sufficient on its own to call this tool correctly without reading the whole schema.

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

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

Schema description coverage is 58%, below the 80% baseline, so the description should compensate for undocumented parameters — and it does not. Key fields like model (9-value enum), style, title, filename, and negativeTags have no description text anywhere, and the description mentions no parameter semantics at all.

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 ('Add AI vocals to uploaded instrumental audio') and names the provider (Suno), so the agent knows exactly what the tool produces. It does not explicitly contrast itself with close siblings such as add_instrumental (the inverse operation) or extend_music, but the operation 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?

There is no when-to-use or when-not-to-use guidance, and no alternatives are named. The agent must infer that uploadUrl must come from a prior upload (e.g. upload_file) and that check_task/download_result are the polling path — none of that routing is 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, the description carries the full behavioral burden, yet it only restates the input/output shape. For a credit-consuming, likely asynchronous job it never says that credits are spent, whether the call blocks or returns a task handle, how large inputs are handled, or what the output artifact looks like. The schema hints at cost controls but the description itself is thin.

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 immediately followed by the input/output contract. No filler.

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

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

The description is adequate for what the tool produces, and no output schema exists so return-value detail is minimal. However, for a paid generation tool with no annotations, it omits the cost/async behavior an agent needs to call it safely and to choose it over separate_vocals.

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 filename, audio_url, max_credits, download_dir, and estimate_only are already fully documented in structured data. The description adds no extra semantics for any of them, so baseline 3 applies.

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

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

States a specific verb (isolate) and resource (vocals/audio) and clarifies the transformation: input URL in, clean isolated audio out. It does not, however, distinguish itself from the sibling separate_vocals, leaving the agent to guess which of the two isolation tools to pick.

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

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

There is no when-to-use guidance, no exclusions, and no mention of the closely related separate_vocals sibling. The only structural hint is the schema's estimate_only note about expensive runs, which is not framed as selection guidance.

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

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

No annotations are provided, so the description carries the full burden. It never says whether this submits a billable task, whether it is a pure text transform, or what the returned enhanced description looks like, despite max_credits and estimate_only parameters strongly implying credit-spending behavior that goes unmentioned 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 that covers purpose, input, and output. The 'NEW —' prefix is marketing noise that earns no place, but the rest is tight with zero redundancy.

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

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

For a simple text-transform tool with no output schema and no annotations, the description covers the core purpose but omits what the enhanced output looks like and whether the call consumes credits, which the credit-related parameters make a relevant open question.

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 content, max_credits, and estimate_only thoroughly (including override precedence and estimate semantics). The description's only added parameter meaning is the input example 'Pop, Mysterious', which lightly clarifies expected content format; baseline 3 applies.

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

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

The description names a specific verb (convert) and both the input (concise style text) and output (enhanced style description), with a concrete example. It clearly reads as a style-expansion utility rather than a generation tool, though it doesn't explicitly position itself against generate_music, its most likely companion.

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

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

The phrase 'for music generation' implies the output feeds a downstream generation call, giving implied usage context. There is no explicit statement of when to reach for boost_style versus just passing a style directly to generate_music, and no alternatives are named.

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

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

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 carries the full burden, yet it only restates the save location that download_dir's schema already documents. It says nothing about default blocking behavior, credit consumption (the schema implies credits are billed via max_credits), or how async polling works.

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, with no filler or repetition.

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, a synchronous/async fork, and a credit-charging model, the description is thin, but the rich schema covers most of the operational detail. It is minimally adequate, with the credit and blocking-default story left entirely to the schema.

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

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

Schema coverage is 88%, so per-parameter semantics are already well documented in the schema. The description adds no parameter-level detail, making the baseline 3 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 and resource ('Convert a Suno track to lossless WAV format') plus the output destination, which is more precise than most siblings. It does not explicitly differentiate itself from adjacent tools like download_result or separate_vocals, but the conversion framing is distinguishable.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. a completed Suno generation task must exist), and no routing toward or away from siblings. Some usage hints exist, but they live in the schema (wait, estimate_only) rather than the description.

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

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

No annotations are provided, so the description carries the full burden, yet it says nothing about credit cost, latency/blocking behavior, where output lands, or whether the operation is idempotent. The schema parameters (max_credits, estimate_only, download_dir) hint at these traits, but the description body itself discloses none of them.

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

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

A single front-loaded sentence with zero waste and a clear verb-resource-mechanism order. It is efficient, though arguably undersized for a 15-parameter tool with no annotations, which keeps 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 15-parameter, 60%-covered, no-annotation, no-output-schema tool, the description is too thin: it omits cost/credit implications, the async workflow, output location defaults, and the relationship to sibling extend/add_vocals tools. An agent could invoke it but would miss important operational context.

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

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

Schema coverage is 60% with 15 parameters, so the schema does much of the work. The description's mention of vocals, style, and instrumentation loosely maps to vocalGender/style/instrumental, but adds no syntax, format, or interaction details beyond what the schema fields already state – roughly baseline for this coverage level.

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 (create an AI cover from uploaded audio) and names the key axes: custom vocals, style, instrumentation via Suno. It is reasonably distinguishable from siblings like generate_music or add_vocals, but it never explicitly contrasts itself with them, so it falls short of a 5.

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

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

The description offers no when-to-use guidance, prerequisites, or named alternatives among the many sibling generation tools (generate_music, extend_music, add_vocals, upload_extend_audio). The async/polling advice exists only inside the schema's `wait` parameter, not in the tool description itself.

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 disclosure burden. It reveals a side effect (writes an MP4 into kie/assets/raw/), but says nothing about cost/credits, the fact that blocking is the default (wait=true), or async behavior — all of which live only in the schema, leaving a real gap for a paid generative tool.

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

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

Two short sentences, front-loaded with the action and output artifact, no filler. The second sentence is a fragment, but it earns its place by naming the download destination.

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 costly generative tool with 10 parameters, no output schema, and no annotations, the description is thin. The rich schema compensates on parameters, but credit behavior, blocking-vs-async default, and what the returned MP4 contains are left unaddressed.

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

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

Schema coverage is 90%, so the schema already documents taskId, audioId, wait, estimate_only, max_credits, max_wait_seconds and download_dir in detail. The description adds no parameter-level meaning beyond pointing at the Suno source, so baseline 3 is correct.

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, output format, and source: 'Generate an MP4 music video visualization from a Suno track.' This tells an agent it produces video from an existing Suno track, distinguishing it from generate_music (audio) and generate_video (generic video). It stops short of naming the sibling it most resembles (generate_video) to make the split unambiguous.

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

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

The description implies a prerequisite (a Suno track must exist) but gives no explicit when-to-use or when-not-to-use guidance, and never contrasts itself with generate_video. An agent gets no routing rule for choosing this over other video 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 full behavioral burden but discloses little beyond 'returns characterId'. It does not explain credit implications, whether the character persists/is reusable across calls, idempotency, or any auth/rate constraints, even though the schema hints at billing behavior via max_credits and estimate_only.

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

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

Three short, front-loaded sentences with no waste; the key action and return value lead. The 'NEW —' prefix is marketing rather than functional, but costs nothing.

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

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

No output schema exists, but the description does name the return value ('characterId'), which is the essential output. For a creation tool with zero annotations, it should say more about persistence, cost, and failure behavior, so it is only minimally 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 schema already documents every parameter thoroughly. The description adds only high-level mapping ('image + optional voice') to image_urls/audio_ids. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Create a reusable visual character for Gemini Omni video generation') and clarifies it 'combines image + optional voice', which helps distinguish it from create_omni_voice. It never names a sibling explicitly, but the scope is clear enough for an agent to select it.

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

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

Usage is only implied by 'for Gemini Omni video generation'. There is no explicit when-to-use/when-not-to-use guidance, no mention of prerequisites (e.g. needing an existing voice ID from create_omni_voice), and no routing to alternatives.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the created voice is persistent/reusable and returns a kieAudioId handle, which is the key output fact given there is no output schema. It says nothing about cost, credit consumption, provisioning latency, or whether the creation is reversible — notable omissions for a mutation tool whose own schema exposes max_credits/estimate_only guardrails.

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 zero padding; the core action leads and the return-value/downstream-use fact follows immediately. The only removable token is the 'NEW —' marker, which is minor.

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 six-parameter mutation tool with no output schema, the description does cover the most important missing structured data (the kieAudioId return handle) and its consumer. It remains thin on billing/cost behavior and asynchronous execution, leaving the agent without the context it would need to call this responsibly alongside estimate_only and max_credits.

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 six parameters, including the 30-value audio_id enum and the voice_description/example_dialogue distinction. The description adds no further parameter semantics (e.g. how voice_description shapes the preset), so the baseline 3 applies.

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

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

States a specific verb and resource — 'Create a reusable voice character for Gemini Omni video generation' — and names the artifact it produces (kieAudioId) plus its downstream consumer. It scopes itself to Gemini Omni, which partly separates it from create_voice_clone and create_omni_character, but it never names those siblings explicitly, so the differentiation is only implicit.

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

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

The description implies when to use it by naming the downstream call site ('for use in generate_video audio_ids'), which tells the agent this belongs to the Omni video pipeline. However it gives no explicit when-not-to-use guidance and never contrasts with the closely related create_voice_clone, prepare_voice_clone, or create_omni_character 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 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 burden and delivers very little: it does not mention that this is a credit-consuming generation, that it returns an async task_id, or anything about billing/reversibility. The behavioral detail that does exist (async wait, max_credits, estimate_only) lives entirely in schema parameter descriptions, which the description does not reference.

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

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

Two tight sentences, front-loaded with the core action and scope, with no padding. The second sentence overlaps with the audioId schema description, costing minor redundancy.

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

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

For a 13-parameter credit-consuming generation tool with no annotations and no output schema, the description omits cost implications, the async result shape, and how the extended segment relates to the original track. The rich schema compensates substantially, but a caller reading only the description would not know this is a billable generation.

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 77%, so the schema already documents most parameters in detail, including prompt, wait, max_credits, and continueAt. The description adds only that audioId comes from a previous generation, which the schema also states — a 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 and resource ('Extend/continue an existing Suno track from a specific point') and adds the required lineage of the input. It is not explicitly contrasted with nearby siblings like generate_music, replace_section, or cover_audio, so it stops short of full differentiation.

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

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

It gives one real prerequisite — audioId must come from a prior generate_music task — which implies this is a follow-on operation rather than a fresh generation. However, it never says when to choose this over add_instrumental, replace_section, or regenerate-style siblings, so usage is largely inferred.

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

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

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 the full burden. It usefully discloses the provider/model and the filesystem side effect ('Downloads to kie/assets/raw/'), but says nothing about credit consumption, blocking vs async behavior, or auth — details the agent must recover from the schema parameter descriptions instead.

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

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

Three short sentences with zero filler: what it does, what it is good for, and where the output lands. Everything is front-loaded and no sentence is redundant.

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

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

For a nine-parameter generation tool with a fully documented schema and no output schema, the description plus schema give the agent enough to invoke it correctly: engine, speaker model, and destination directory. The only shortfall is the missing explicit routing against the other TTS siblings, which is a usage rather than an invocation gap.

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

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

Schema description coverage is 100%, so all nine parameters, including the dialogue array shape, wait/async flow, credit guard, and estimate_only, are already documented in the schema. The description adds no parameter-level meaning beyond that, which is the correct baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('Generate multi-speaker dialogue') and names the underlying engine (ElevenLabs Text-to-Dialogue V3 via kie.ai). The 'multi-speaker' qualifier implicitly separates it from the single-speaker siblings generate_tts and generate_gemini_tts, though it never names an alternative, so the differentiation is inferential rather than explicit.

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

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

'Great for conversations between characters' implies the use case (multi-character dialogue) but is a soft recommendation rather than a rule. There is no statement of when NOT to use it, and no pointer to generate_tts/generate_gemini_tts for single-speaker output, leaving the agent to infer the boundary.

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 per-minute credit cost, the quality degradation on long flash takes, the default download destination (kie/assets/raw/), and the model tradeoffs. It does not address auth requirements, failure modes, or what happens on partial/retry runs.

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 opening is front-loaded with the distinguishing identity ('NEW — Google Gemini native TTS') before cost and modes, which is the right order for an agent. It is dense and somewhat list-like, and pricing appears both here and again per-model in the schema, but for a 14-parameter multimodal generation tool the length is largely justified.

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

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

For a complex, annotation-free tool with no output schema and zero required parameters, the description covers the essentials an agent needs: mode selection, model choice, cost ceiling rationale, and output location. It omits guidance on failure/async recovery beyond the schema's own wait note, and gives no indication of rate limits or concurrency.

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 93%, so the baseline is 3; the description adds value by grouping the 14 flat parameters into coherent modes ('Simple mode: pass text', 'Dialogue mode: pass speakers + dialogue_turns') and explaining the model enum's cost/quality tradeoffs rather than just listing values. It stops short of explaining mutually exclusive combinations or precedence rules beyond the single 'Ignored if dialogue_turns is set' note.

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

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

The description identifies a specific resource (Google Gemini native TTS via kie.ai) and enumerates distinguishing capabilities: style-directed speech, 30 named voices, up to 2 speakers, inline tone tags. It implicitly separates itself from the ElevenLabs-based siblings via 'cheaper than all ElevenLabs tiers,' but it never names generate_tts or generate_dialogue, so the differentiation is inferential rather than explicit.

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

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

Usage context is unusually concrete: it distinguishes Simple mode (text + optional voice_name) from Dialogue mode (speakers + dialogue_turns), and gives model-selection heuristics (flash for expressive short takes, pro for multi-minute stability). What is missing is an explicit 'use this instead of X' or when-not-to-use statement relative to the sibling TTS 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 disclosure burden and mostly succeeds: it reveals cost in credits per model, approximate latency (~13s, ~4s), the 60+ model catalogue size, output landing directory (kie/assets/raw/), and the async submit-and-poll workflow. It does not state authentication/permission requirements or whether a submitted generation is cancellable, so it stops short of 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?

Purpose and the profile_brief tip are front-loaded, but the MODEL GUIDE becomes a dense run-on with repeated 'NEW' markers and per-model credit notes that partly duplicate what list_models already exposes. Information-dense but over-stuffed for a description field.

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

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

For a complex 11-parameter, 60+-model generation tool with no annotations and no output schema, the description covers model routing, cost, timing, async behavior, and output location well. It leaves the concrete response shape largely to the schema's async description, which is a minor gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The MODEL GUIDE adds genuine value beyond the schema by mapping use cases to concrete model IDs and their credit/speed tradeoffs, which directly informs the `model` parameter. It also reinforces the output location relevant to `filename`/`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?

States a specific verb and resource ('Generate an image using kie.ai') and immediately differentiates from siblings by routing related tasks to seedream_layer_decompose, grok_image_edit, and grok_segment_map. An agent can tell this apart from generate_video or generate_cover_art without reading schemas.

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

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

Explicitly names alternatives and the conditions that select them: profile_brief for architecture/game-art/advertising/product-UI, seedream_layer_decompose for layer splitting, grok_image_edit for refinement, list_models to explore. It also tells the agent when to prefer estimate_only and async mode for long runs.

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

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

With no annotations, the description carries the full burden. It usefully discloses the output modality ('Returns text, no file download'), which saves a pointless download_result call, and the 200-char prompt ceiling. However, it says nothing about credit consumption, even though max_credits/estimate_only exist and this is a billed Suno AI call — a material gap for a paid operation.

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

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

Two short sentences, front-loaded with the core action, and the output-modality caveat immediately follows. Nothing extraneous beyond a minor duplication of the 200-char limit already in the schema.

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

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

For a 3-param, no-output-schema tool this covers the essentials: what it produces and that no file is returned. It omits whether the call is synchronous or submit-and-poll (relevant given the many check_task-style siblings) and gives no hint that the call spends credits, so it is adequate but 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 100%, so the schema already documents prompt's 200-char limit, max_credits and estimate_only in detail. The description only restates the prompt limit and adds no new meaning for any parameter, 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 (generate song lyrics) plus an output modality ('Returns text, no file download'), which separates it from audio-producing siblings like generate_music and from the retrieval-oriented get_timestamped_lyrics. It does not name a sibling explicitly, so it stops just short of a 5.

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

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

Usage is implied — reach for this when you want lyric text rather than an audio artifact — but there is no explicit when-to-use/when-not statement and no mention of how it relates to generate_music or get_timestamped_lyrics. No alternatives or exclusions are given.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers only one sentence. It omits that this consumes credits, that output requires subsequent download, and that blocking vs async behavior is configurable — details that live only in the schema parameter text, not 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?

Two short, front-loaded sentences with no padding beyond the 'NEW —' marketing prefix, which is noise but minor. The core scope constraint comes first where an agent will read it.

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 no annotations and no output schema, a single sentence is thin. It never mentions that the result is an async task costing credits, what the model enum implies for quality, or anything about retrieval of the generated track.

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 80% schema description coverage, the schema already documents the notable parameters (wait/async mode, max_credits, estimate_only, download_dir, max_wait_seconds). The description only restates the audioIds constraint ('up to 2'), adding no format, sourcing, or interaction detail beyond the schema.

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

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

States a specific verb and resource — mash up Suno tracks into one new track — and gives a bounded scope ('up to 2'). It is clearly distinct from sibling transformations like extend_music, cover_audio, or add_instrumental, though it never names an alternative to contrast against.

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

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

'Provide audioIds from previous generations' hints at the input prerequisite but says nothing about when this tool should be chosen over cover_audio, extend_music, or add_vocals. No exclusions, no cost context, no guidance for how many or which tracks are suitable.

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

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

With no annotations, the description carries the full burden. It discloses the output location and file type (.mid downloaded to kie/assets/raw/), which is useful behavioral context. However, it omits credit consumption, async behavior, permission requirements, and failure modes, leaving clear 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 short sentences, front-loaded with the core action and immediately followed by the output destination. No wasted words or redundant information.

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

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

For an 8-parameter tool with no annotations and no output schema, the description is minimal. It states purpose and output location, and the schema covers most parameter details, but it does not mention credit implications, async mode, or when to prefer this over sibling conversion tools.

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

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

Schema description coverage is high (88%), so the schema already documents nearly all parameters in detail. The description adds no parameter-level meaning beyond what the input schema provides, making the baseline score of 3 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 (Export) and resource (Suno track to MIDI notation), making clear this is a format conversion tool. The output target is also named, which further distinguishes it from audio-generation siblings like generate_music or convert_to_wav.

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

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

The description gives no when-to-use guidance, no prerequisites, and does not name any alternative tools. It implies the tool is used when a Suno track needs MIDI export, but provides no routing context relative to siblings such as convert_to_wav or separate_vocals.

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, and it does disclose the default blocking/polling behavior and the output destination ('Polls until done and downloads to kie/assets/raw/') plus an 8-minute duration limit. It omits credit/cost behavior (only hinted at in the schema), failure/timeout handling, and auth requirements, leaving meaningful gaps for a tool with 11 parameters.

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

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

Four short sentences, front-loaded with the core action and provider, then capabilities, use cases, and execution behavior. The V5.5/V5/V4.5 enumeration is somewhat redundant with the schema enum descriptions, costing a little efficiency, but there is no padding overall.

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

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

There is no output schema, so the description helpfully states that results are downloaded to kie/assets/raw/. Combined with 100% schema coverage for all 11 parameters (including the async wait/check_task/download_result flow), an agent has enough to invoke correctly, though it lacks cost and failure-handling detail.

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, setting the baseline at 3. The description adds only marginal meaning by glossing model tiers ('V5.5 custom style, V5 best quality') and the duration cap, which largely restate information already present in the enum and 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?

States a specific verb and resource ('Generate music') and names the underlying provider (Suno via kie.ai), which is enough to separate it from generate_sfx, generate_tts, and generate_lyrics. It does not, however, explicitly distinguish itself from music-adjacent siblings like extend_music, cover_audio, or add_instrumental, so it falls short of the 5-level sibling differentiation.

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

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

The phrase 'Great for game music stems, ambient tracks, and jingles' gives implicit usage context, and the model list implies quality/style tradeoffs. But there is no explicit when-to-use-this-vs-siblings guidance (e.g. vs extend_music or cover_audio) and no stated prerequisites or exclusions, so routing remains largely inferential.

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?

There are no annotations, so the description carries the full burden; it discloses the provider/model, that the previous ElevenLabs model was removed, and the default download destination (kie/assets/raw/). It does not mention cost/credit expenditure in the description itself, though the max_credits and estimate_only params cover that ground in the schema.

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

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

Three tight sentences, front-loaded with the verb+resource, then differentiation, then the output location. The game-sound examples earn their space by anchoring the intended prompt style; nothing is redundant.

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

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

For a 9-parameter generation tool with no annotations and no output schema, the description covers purpose, the sibling alternative, and where files land, while the schema handles the async/cost mechanics. The main gap is that the description never states the tool spends credits or what a returned task looks like, leaving that entirely to the parameters.

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

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

Schema description coverage is 100%, and the schema already documents every parameter including async behavior and the deprecated prompt_influence flag. The description adds no syntactic or format detail beyond what the schema provides, so the baseline of 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 ('Generate a sound effect from text') plus the engine ('via Suno V5'), and explicitly separates itself from generate_sounds for loop/BPM/key control. An agent can pick between the two sibling generators 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?

Names the alternative (generate_sounds) with the condition that selects it, gives concrete use-case examples (UI clicks, magic spells, pickups, explosions), and flags the async path ('wait=false... poll with check_task') for long generations. When-to-use, when-not-to-use, and alternatives are all present.

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 disclosure burden. It does reveal one genuine side effect — files are downloaded to kie/assets/raw/ — but says nothing about credit consumption, async/polling behavior, permissions, or what the caller receives, all of which matter for a 12-parameter generation tool.

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

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

Two compact sentences with the core capability front-loaded and the output destination trailing. No filler, though the second sentence is a fragment that could be folded into the first.

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 rich schema descriptions (wait/async mode, download_dir, estimate_only, max_credits) compensate for much of the terse description, and no output schema exists to explain. Still missing sibling disambiguation and any cost/return expectations, which leaves gaps for a 12-parameter tool with no annotations.

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

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

Schema coverage is 75%, so the schema already documents most parameters well. The description echoes the key ones ('BPM, key, and loop control' mapping to soundTempo, soundKey, soundLoop) but adds no syntax, ranges, or format guidance beyond the schema.

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

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

States a specific verb and resource ('Generate loopable sound effects') plus the differentiating attributes (BPM, key, loop control) and the provider (Suno). However, it never distinguishes itself from the close sibling generate_sfx or from generate_music, so an agent cannot tell from the description alone which sound-generation tool to pick.

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

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

There is no when-to-use guidance and no mention of alternatives. The sibling list contains generate_sfx and generate_music, whose overlap with this tool is exactly the ambiguity the description should resolve, and it does not.

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 disclosure burden. It does add real behavioral context — the file is written to kie/assets/raw/ (a local side effect) and calls are routed through kie.ai — but it omits cost/credit implications, blocking-vs-async behavior, and failure modes that an agent needs before invoking an 11-parameter generation tool.

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

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

Two short sentences, front-loaded with the purpose, no filler. The trailing download-path sentence partly duplicates the download_dir schema default, which is the only minor redundancy.

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

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

For an 11-parameter generation tool with no output schema, the description leaves out cost expectations, output/variant behavior, and routing against the gemini TTS sibling. The rich schema compensates for parameter-level gaps, but the description is only minimally 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 every parameter is already self-documented; the baseline is 3. The description only restates the two model names (already the enum) and the download location, adding essentially nothing semantic beyond the schema.

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

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

States a concrete verb+resource ("Generate speech from text") and pins the provider stack (ElevenLabs via kie.ai), which implicitly separates it from the sibling generate_gemini_tts. However, it never names that sibling or any other alternative, so the differentiation must be inferred rather than read.

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

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

The description gives no when-to-use guidance: nothing explains when an agent should pick this over generate_gemini_tts, generate_dialogue, or generate_music. Model selection (turbo vs multilingual) is present but that is configuration, not usage 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?

With no annotations, the description carries the full burden and does substantial work: it discloses download location, per-model credit rates, failure modes (Veo I2V intermittently failing its audio pass without a sound cue), and the Content-Type requirement for input images. It omits auth/permission requirements, rate limits, and what a successful submission returns in blocking mode, which keeps it short of a 5.

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

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

The purpose and destination are front-loaded, and nearly every clause routes a real decision. However, it is a single dense paragraph of model catalog data with heavy abbreviations ("50cr/s", "I2V"), which is unwieldy for a description field and would be better served as a browsable resource or via list_models.

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

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

For a complex 11-parameter tool with no annotations and no output schema, the description covers the decision space an agent needs: model choice, cost, download path, async workflow via check_task/download_result, and cross-tool routing. Return-value details are unnecessary since generation output is a downloaded file.

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 on top of it: valid model ID examples, the model_options.draft=true pattern, when to use estimate_only before expensive runs, and the requirement that image_urls be served with their real Content-Type via upload_file.

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

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

Opens with a specific verb+resource ("Generate a video using kie.ai") and names the destination path. It clearly distinguishes itself from siblings like generate_image and generate_music, and explicitly delegates adjacent jobs (extend video → veo_extend/runway_extend, model discovery → list_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?

A detailed model-selection guide maps use cases to concrete model IDs (cinematic, budget, image-to-video, lip-sync, motion control, avatar, first/last-frame), including per-use-case caveats and prices. It also states when to reach for other tools (veo_extend, runway_extend, upload_file, check_task, 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?

No annotations are provided, so the description carries the full burden. It omits whether the call is a paid submission, whether it is synchronous or returns a task to poll, and what the timestamp format is. The credits/estimate caveat lives only in the schema, not here.

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 compact sentences with the core action front-loaded. The 'NEW —' prefix is marketing noise that earns no space but does little harm.

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 annotations and no output schema, the description should cover more: whether results are returned inline or via check_task/download_result, and what the timestamped payload looks like. It establishes the purpose but not the operational picture.

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

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

Schema description coverage is 100% and the schema itself documents taskId, audioId, max_credits and estimate_only in detail. The description adds no parameter meaning beyond 'from a Suno track', so the baseline of 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 ('Get word-level timestamped lyrics from a Suno track') and even names the output granularity (word-level timestamps), which cleanly separates it from generate_lyrics and speech_to_text. It does not explicitly name a sibling to contrast against, so it stops short of a 5.

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

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

'Useful for karaoke, captioning, or sync' implies the intended scenarios but gives no when-to-use vs when-not-to-use guidance and no prerequisites. Nothing tells the agent it needs an existing Suno task/audio before calling.

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 so well: it discloses the 4-credit cost, that segmentation is free, that the result is a NEW full image (implying the source is not destroyed), that result task_ids can be chained for iterative refinement, and that output downloads to kie/assets/raw/. It does not cover auth requirements or failure modes, so not 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?

Dense but well front-loaded: the core action and cost come first, then the two modes in parallel structure, then the return/chaining note. The parentheticals ("run it first, free", "NEW Aug 2026") are informative rather than filler, though the sentence is long enough that some readers may skim.

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

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

No output schema exists, and the description compensates by explaining what comes back (a new full image, reusable task_ids for chaining) and where files land. Combined with mode routing and the cost/estimate hint, an agent has everything needed to invoke this correctly.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds real signal by grouping the 9 parameters into two mutually exclusive modes and explaining cross-parameter interaction (task_id vs image_urls, when aspect_ratio applies). This helps an agent pick a valid parameter combination rather than just read individual field docs.

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 (Edit) and resource (image) with the exact model (Grok Imagine Image 2.0), and separates the tool into two named modes with distinct inputs. An agent can distinguish this from siblings like generate_image or grok_segment_map 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?

Gives explicit routing: region mode requires task_id + mask_indexs obtained from grok_segment_map (which it says to run first, free), whole-image mode accepts any image_urls plus aspect_ratio. It names related tools (grok_segment_map, upload_file) and their role. It stops short of stating when NOT to use this tool versus e.g. generate_image, so not a full 5.

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

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

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?

No annotations are provided, so the description carries the full burden. It flags the tool as EXPERIMENTAL, which is useful, but does not disclose credit consumption, idempotency, what happens to the original failed task's assets, or the meaning of max_credits/estimate_only behavior at the task level.

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

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

A single efficient sentence with the experimental warning front-loaded before the actionable purpose. No wasted words, though brevity borders on under-specification rather than deliberate tightness.

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 retry/mutation tool with no annotations and no output schema, the description is thin: it never addresses cost, side effects, or the relationship to the sibling voice-clone tools. The EXPERIMENTAL marker and the schema coverage of parameters cover the basics, but richer guidance is missing.

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

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

Schema description coverage is 100%, so the schema already documents task_id, max_credits, and estimate_only in detail. The description only reinforces task_id ('by its task_id') and adds nothing beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb and resource: retry a failed/incomplete custom-voice task, keyed by task_id. This clearly separates it from create_voice_clone and prepare_voice_clone, though it does not explicitly name those siblings.

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

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

Implies usage via 'retry a failed/incomplete' task, which hints at the recovery scenario. However, it never names the alternative tools or states the precondition (e.g., that a prior create_voice_clone must have failed), leaving the agent to infer.

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 says nothing about whether the original track is overwritten or preserved, whether the edit is reversible, credit cost, or async behavior. Some of this (async mode, max_credits, estimate_only) is covered in the schema descriptions, but the free-text description itself contributes no 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, front-loaded sentence with no filler. It is efficient, though arguably too sparse for a 15-parameter mutation tool.

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

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

For a 15-parameter, 5-required mutation tool with no annotations and no output schema, the description is far too thin. It omits destructive/overwrite semantics, usage context, and how it relates to the numerous sibling audio tools.

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

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

Schema description coverage is 73%, moderately high, so the schema does most of the work. The description's mention of a 'time range' and 'new AI-generated content' loosely maps to infillStartS/infillEndS and prompt but adds no new semantics for the remaining parameters (tags, negativeTags, title, fullLyrics).

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 (replace) applied to a specific resource (a time range in a Suno track) with a clear outcome (new AI-generated content). This distinguishes it conceptually from siblings like extend_music or add_instrumental, 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?

There is no guidance on when to use this tool versus the many other audio-editing siblings (extend_music, cover_audio, add_instrumental, add_vocals). No prerequisites or context conditions are given, so the agent must infer usage 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 says nothing about the fact that this is a paid, credit-consuming video operation (implied by max_credits/estimate_only params), whether it is asynchronous, or what happens to the original video — all critical for an expensive 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?

A single, front-loaded sentence with no filler. It is efficient, though its brevity leaves behavioral gaps that are captured elsewhere rather than here.

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, cost-bearing video generation tool with no output schema, one sentence is inadequate. It omits cost/credit behavior, prerequisites, and how it relates to the veo_extend sibling, leaving the agent under-informed before an expensive 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 71%, so most parameters are documented in the schema itself; the description adds no additional parameter meaning. The estimate_only, max_credits, and download_dir descriptions live entirely in the schema, which is adequate for this coverage level.

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 ('Extend'), the exact resource ('an existing Runway Aleph video'), and the output nature ('continuation content'). It clearly describes what the tool does, but does not differentiate itself from the sibling 'veo_extend', which presumably performs an analogous extension for a different model family.

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

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

There is no guidance on when to use this tool versus alternatives, despite 'veo_extend' being a close sibling for the same extension use case. It also omits the prerequisite that the task_id must come from an original Runway generation, forcing the agent to infer this from the schema.

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-layer billing model (including the base layer), the exact credit rates per tier/size, the side effect of downloading every layer to kie/assets/raw/, the public-URL-only constraint with upload_file as the workaround, and the max_credits submission guard. It omits failure/overwrite behavior and whether the call is blocking or async.

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

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

Front-loads the core action, then cost, then workflow in a compact block with no filler sentences. There is mild redundancy, since the tier/size credit rates appear in both the description and the schema descriptions.

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 nine-parameter, no-output-schema tool, the description covers the essentials: what it produces (per-layer downloads), where output lands, prerequisites, cost controls, and how to shape the split via prompt. Only error handling and output naming/ordering detail are absent.

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

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

Schema coverage is 100%, so the schema already documents all nine parameters, including tier and size pricing. The description largely restates the tier/cost tradeoff rather than adding new meaning, though it does supply a concrete prompt example with <bbox> syntax that illustrates how the prompt parameter is used.

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

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

States a precise verb+resource+engine: 'Split ANY image into independent layers with Seedream 5.0'. It is immediately distinguishable from siblings like generate_image, grok_image_edit, or audio tools, and it even names the upload_file prerequisite for local files.

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 real selection guidance — tier='pro' vs tier='flash' with cost tradeoffs, the warning that flash without a prompt explodes layer count (12 layers = 38.9 cr), and 'use estimate_only before expensive runs'. It never names an alternative tool to use instead, so it falls short of the 5-bar.

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 supplied, so the description carries the full behavioral burden. It does disclose the default download destination (kie/assets/raw/), which is useful, but it omits that this submits a credit-consuming paid job, that it blocks by default, and that async submission/polling is possible — all behaviors an agent needs to avoid surprises.

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 ending with the download side effect. Nothing is padded, though the extreme brevity leaves gaps it could have filled cheaply.

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 paid generation tool with no annotations and no output schema, the description is thin: it does not mention the required taskId/audioId inputs, credit consumption, or the async submit-then-poll workflow. The rich inline schema descriptions compensate substantially, but the top-level description is only minimally 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 89%, so the schema already documents nearly every parameter, including the type enum's three modes, wait/async behavior, and credit guardrails. The description adds no syntax or format detail beyond what the schema provides, 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?

Names a specific verb (separate/split) and resource (vocals, instrumentals, individual stems), so the agent immediately knows the operation. However it never distinguishes itself from the close sibling audio_isolation, which plausibly overlaps.

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 what it does but gives no when-to-use guidance, no prerequisites (it needs an existing Suno taskId/audioId), and no routing versus siblings such as audio_isolation or add_vocals/add_instrumental. The 'or split into individual stems' phrasing hints at the type enum but does not explain when each mode is appropriate.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the model and that diarization/event tagging are supported, but says nothing about whether the call is synchronous or returns a task id for check_task, credit cost, audio length/format limits, or failure modes — all material for a 6-parameter media 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?

Three short sentences, front-loaded with the core action and engine, then capabilities, then return type. With no output schema present, the 'Returns transcription text' line earns its place rather than repeating structured data.

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

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

For a tool with no annotations and no output schema, the description covers purpose, engine, optional features, and return type adequately. It omits the async/task lifecycle (check_task exists as a sibling), cost behavior, and input constraints, leaving real gaps for an agent 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 description coverage is 100%, so each of the 6 parameters is already documented, giving a baseline of 3. The description restates two of them (diarization, audio event tagging) without adding syntax, defaults, or interaction rules, so it does not rise above the schema.

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

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

States a specific verb+resource ('Transcribe audio to text') and names the underlying engine (ElevenLabs Scribe v1), which unambiguously separates it from the text-to-speech siblings like generate_tts. It stops short of explicitly contrasting with any named sibling or stating scope limits (duration, size), so it lands just under a 5.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternatives. Useful routing hints such as 'use estimate_only before expensive runs' exist only in the schema property text, not in the description the agent sees first.

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 data-resolution order (actual charged credits → live kie lookup via refresh → published prices marked 'est.') and that failed/refunded tasks are reported separately. It omits any note on permissions, network cost of refresh, or degraded behavior when refresh is false.

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 dense paragraph, front-loaded with the question the tool answers, then the mechanics. All sentences carry information, though the rhetorical opener costs a few tokens for little semantic gain.

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 and no annotations, the description does the necessary work: it explains the grouping dimension, the 'est.' marker, and separate listing of failed tasks, so an agent can anticipate the shape of results. It stops short of describing the return structure precisely.

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 67% and the description adds real meaning for refresh ('looks up missing ones from kie'), explaining the fallback chain the flag controls. It adds context beyond the schema's flat parameter descriptions, though 'days' and 'group_by' add nothing new.

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 ('Totals kie.ai spend from this server's task history') and names the exact data source (kie/assets/task-history.jsonl). It is clearly distinguishable from generation siblings and even from balance-oriented tools like check_credits.

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 'last N days' framing and grouping options imply when to reach for it, but no explicit when-to-use or alternative is given (e.g. check_credits for remaining balance vs this for historical spend). 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?

No annotations are provided, so the description carries the full burden, and it does disclose that this is a generative extension of an uploaded asset. However it omits behavioral traits an agent would want — that it submits a credit-billing generation, the async/polling option, and long-run timeouts — though much of that is covered in the schema. Given zero annotation coverage and a two-sentence description, this is adequate but not rich.

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

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

Two sentences, zero waste, and the routing distinction is front-loaded in the first clause. The 'NEW —' marker is a minor framing tag rather than filler.

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

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

For a 13-parameter generation tool with no annotations and no output schema, the description is very thin — it covers only the routing distinction and says nothing about async behavior, credit accounting, or return handling. The rich per-parameter schema descriptions do much of the heavy lifting, which keeps this at minimum-viable rather than inadequate.

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 69%, and the description adds no parameter-level meaning whatsoever. With majority-but-not-full schema coverage, the baseline of 3 applies; the description does nothing to compensate for the remaining undocumented parameters.

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

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

The description names a specific verb and resource ('Extend uploaded audio with new AI-generated content') and, critically, states the scope boundary ('NOT a Suno track'). It distinguishes itself from sibling extend_music without the reader needing to open 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?

It gives an explicit routing rule: use this tool for uploaded audio, use extend_music for Suno tracks. The alternative sibling is named and the condition that selects it is stated, leaving nothing 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, 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?

With no annotations, the description carries the full behavioral burden and does not disclose that this is a paid, likely async generation that may need polling via check_task, or any permission/credit implications. The schema's estimate_only hint alludes to expensive runs, but the description itself adds essentially nothing beyond the operation name.

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 tightly written sentences with the operation and its prerequisite front-loaded, no filler. It is concise and readable, though arguably too terse for an 8-parameter generation tool.

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

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

For an 8-parameter, no-output-schema, no-annotation generation tool, the description is thin: it omits cost behavior, async task lifecycle, and return expectations. The rich schema fields partly compensate, but the description leaves the agent under-informed on how the call actually behaves.

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%, and the schema already documents the key parameters including the cost controls (max_credits, estimate_only). The description only echoes task_id's origin, which the schema also states, so it adds little beyond structured data. 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) and resource (an existing Veo 3.1 video), which distinguishes it from generic generation siblings like generate_video. The 'Veo 3.1' qualifier helps separate it from runway_extend, though that differentiation is left implicit rather than stated.

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

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

The prerequisite 'Requires taskId from a previous Veo generation' is stated, which implies when the tool applies. However there is no explicit comparison to alternatives such as runway_extend or veo_upscale_1080p/4k, so the agent must infer when to pick this over those siblings.

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

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

No annotations are present, so the description carries the full behavioral burden, and it does very little: it never says whether upscaling creates a new asset or replaces the source, how long it takes, that it costs credits, or how the result is surfaced. The only behavioral fact conveyed is the source-task dependency.

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, and the capability is front-loaded before the precondition. Every clause earns its place.

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

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

For a 6-parameter mutation-style tool with no annotations and no output schema, the description covers purpose and the required source ID but omits cost/credit implications, output handling (filename/download_dir relationship), and the estimate-only workflow. Adequate but with clear gaps.

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

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

Schema description coverage is 83%, so the schema already documents index, max_credits, download_dir and estimate_only well; baseline is 3. The description's phrase "completed Veo generation" adds a small amount of meaning to task_id (the task must be finished, not merely submitted), but nothing beyond that.

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 (upscale), resource (Veo 3.1 video) and target outcome (1080p), which implicitly separates it from the sibling veo_upscale_4k. It stops short of naming or contrasting the sibling explicitly, so differentiation is inferable rather than stated.

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

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

"Requires taskId from a completed Veo generation" gives one real precondition, which is useful routing information. It never says when to pick this over veo_upscale_4k, or references the estimate_only pre-flight path that the schema recommends for 1080p upgrades.

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 disclose a genuine behavioral trait beyond the schema — the 5-10 minute runtime — but says nothing about cost implications, whether the source video is preserved or replaced, or output delivery.

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

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

Three short sentences, front-loaded with the action, then runtime, then the prerequisite. Every sentence earns its place with zero filler.

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

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

With no annotations and no output schema, the description covers the essential call preconditions and latency, while schema fields handle cost guards and output directory. Remaining gaps — whether the original asset persists and what the returned reference looks like — are modest for a 4K upscale 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 83%, above the 80% threshold, so the schema already documents nearly all six parameters (including failure/refund behavior for max_credits). The description only restates the task_id prerequisite and adds no syntax or format detail beyond it.

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

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

States a specific verb and resource ("Upscale a Veo 3.1 video to 4K resolution") and its resolution scope separates it cleanly from the sibling veo_upscale_1080p 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?

Specifies the precondition "Requires taskId from completed Veo generation," giving clear context for when this tool is callable. It does not explicitly contrast with veo_upscale_1080p or state when 4K is inappropriate (e.g., model/source limits), so no exclusions are offered.

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