suno-mcp

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

No annotations exist, so the description carries the full burden, and it only discloses that the call returns a task id, status, and output URLs. It says nothing about the async task lifecycle, how the wait/poll_interval_ms/timeout_ms parameters interact with that lifecycle, cost, or auth requirements, which is a significant gap for a job-creating 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 followed by the return shape; nothing is redundant. It is economically written, though the brevity comes partly from simply omitting necessary context.

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

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

With 9 parameters, no annotations, and no output schema, the description is too thin: it covers the action and return shape but omits parameter guidance, async behavior, and any sibling routing. An agent would need to open the schema and guess at operational semantics.

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 78%, so most parameters (audio_url, start_seconds, end_seconds, wait, model, callback_url, prompt) are already documented in the schema, making 3 the baseline. The description adds no parameter detail and does not compensate for the two undocumented fields (timeout_ms, poll_interval_ms).

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 and resource ("Create a Suno task on RunAPI") and parenthetically clarifies the operation ("add samples"), which lets an agent distinguish it from siblings like text_to_music or extend_music. However, it never explicitly contrasts itself with a close sibling (e.g. cover_audio), so the differentiation is inferred 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 description gives no when-to-use guidance, no prerequisites, and does not name any alternative tool for audio-sample workflows. The required audio_url/start_seconds/end_seconds triad hints at a sample-a-range operation, but the agent is left to infer when this beats cover_audio or remaster_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 must disclose behavioral traits itself. It states that the tool returns a task id, status, and result payload, which implies an asynchronous task model, but it does not explain side effects, blocking behavior, error handling, or any prerequisites. The lack of detail gives an agent insufficient awareness of execution semantics.

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

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

The description is a single sentence with no fluff, front-loading the action and outcome. It is appropriately concise, though it sacrifices useful details for brevity; still, 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?

For a tool with 6 parameters, no annotations, and no output schema, this description is too sparse. It fails to explain the asynchronous nature, the purpose of wait/timeout/callback parameters, the structure of the result payload, or any constraints. Siblings like generate_lyrics likely have richer contracts, and this description leaves too much to inference.

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

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

Schema description coverage is 67% (4 of 6 params have descriptions), so the baseline is moderate. The tool description itself says nothing about parameters, failing to clarify the two undocumented params (timeout_ms, poll_interval_ms) or how wait interacts with them. It adds no value beyond the schema, which is exactly the baseline scenario.

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 (create a Suno task) and the specific resource/operation (blend lyrics), which is distinct from siblings like generate_lyrics and create_mashup. The verb 'create' and parenthetical 'blend lyrics' make the 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?

The description implies the tool is for blending two lyrics (via 'blend lyrics') but provides no explicit guidance on when to use it over alternatives like generate_lyrics or create_mashup. No exclusions or when-not conditions are given, so usage is only implied.

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

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

With no annotations provided, the description carries the full behavioral burden. It does disclose that the operation is synchronous and that it 'returns the operation result,' which is useful. However, it omits auth requirements (a login sibling exists), failure behavior, rate limits, and whether this is a safe read or a mutating paid call (check_pricing sibling suggests cost implications). The jargon 'boost style' is never unpacked.

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 tight sentence with no filler. The synchronous behavior and return value are front-loaded. Minor deduction for the parenthetical 'boost style,' which is cryptic and could have been replaced with plain language, but overall it's an efficient definition.

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

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

With no output schema and no annotations, the description should explain what the operation result looks like and when the tool is used in a workflow. It only says 'returns the operation result' without any format or usage context. For a single-parameter tool this is passable but leaves the agent guessing about the meaning of 'boost style' and the shape of the return value.

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% — the schema already documents 'description' as 'Style description to expand into genre tags.' The tool description adds essentially nothing about the parameter beyond the parenthetical 'boost style,' so it lands at the baseline 3 for fully-covered schemas.

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 verb (run) and resource (Suno operation on RunAPI), but 'boost style' is unexplained jargon. The schema parameter clarifies it expands style descriptions into genre tags, giving the purpose some grounding. However, it fails to distinguish itself from the many sibling music/audio tools — 'boost style' doesn't convey what outcome the agent should expect.

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 any of the 20 siblings. There's no mention of when boost_style is appropriate (e.g., after generating a style, before text_to_music), no prerequisites, and no exclusions. An agent has no way to route to this tool over inspire_music or generate_persona.

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 responsibility for behavioral disclosure. 'Look up' implies a read-only, non-mutating operation, but it says nothing about authentication, rate limits, response format, caching, or whether the data is live. This is minimal transparency, and important behavioral traits are absent.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the core action and resource, and every part of the sentence contributes meaning. It is appropriately concise for such a simple lookup 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?

The tool is very simple (no required parameters, no output schema, no nested objects). The description covers the core purpose and the schema fully documents the parameters. However, it does not describe what the returned pricing data contains or how to interpret it, which is a gap given there is no output schema. It is adequate but not fully complete.

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

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

Schema description coverage is 100%; both 'model' and 'action' have clear descriptions including defaults in the schema itself. The description text adds no parameter-level semantics beyond what the schema already 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?

The description 'Look up RunAPI pricing for the suno model line' uses a specific verb ('look up') and a specific resource ('RunAPI pricing for the suno model line'). It clearly distinguishes this tool from the sibling audio/action endpoints because it is the only one about pricing. However, it does not explicitly name a sibling or state what it is not, so it doesn't fully earn 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 provides no guidance on when to use this tool versus alternatives. It does not mention checking pricing before running an expensive operation, nor does it note any exclusions or prerequisites. The agent must infer its role from the name alone. There is no explicit context for when it should be called.

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 'Returns a task id, status, and output URLs' but does not reveal that this is an asynchronous long-running task — strongly implied by wait, timeout_ms, callback_url, and poll_interval_ms params — nor that it depends on a prior audio-generation task (source_task_id). These are significant behavioral traits an agent must know before calling.

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

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

A single sentence with zero waste: purpose is front-loaded, operation tag and return info follow immediately. Appropriate length for the tool's complexity.

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

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

Given 6 params, no output schema, and no annotations, the description should disclose the async task behavior, the prerequisite prior-task dependency, and what the output URLs point to. It covers the return values partially, but omits the asynchronous workflow (wait/callback/polling) and source-audio chaining that the parameter set implies. Meaningful gaps remain for an agent deciding how to invoke it.

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

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

Schema coverage is 67% (4 of 6 params documented), which is mid-range. The description adds no parameter meaning whatsoever — it never mentions source_audio_id, wait, callback_url, or the source dependency. The two undocumented params (timeout_ms, poll_interval_ms) are left to be inferred from their names, and the description does not bridge that gap.

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

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

States a specific verb and resource ('Create a Suno task on RunAPI') with an operation tag 'convert audio' and describes return values (task id, status, output URLs). The purpose is clear at a high level, but it does not differentiate 'convert' from closely related audio siblings like remaster_audio, stitch_audio, or separate_audio_stems — what exactly the conversion targets (format? channels?) is left vague.

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 no when-to-use or when-not-to-use guidance. With 20 siblings, many of which also operate on audio (cover_audio, remaster_audio, stitch_audio, separate_audio_stems), the description never names an alternative or a condition for selection. Usage must be inferred entirely from the 'convert audio' parenthetical.

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

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

With no annotations, the description must disclose behavioral traits itself. It only mentions the return values but does not disclose that this is likely an asynchronous task creation with polling/wait options, that it incurs cost, or that it requires authentication. The existence of wait, timeout_ms, poll_interval_ms, and callback_url parameters implies asynchronous behavior, but the description is silent on it.

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

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

The description is a single sentence that quickly states the action and the return type. It is short and front-loaded with the core purpose, with no wasted words.

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

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

For a complex tool with 18 parameters, no annotations, and no output schema, the description is inadequate. It mentions the return values but does not explain how to use the task id, whether to wait, what statuses mean, or any usage constraints. An agent would need to rely on the schema, which still leaves 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?

The schema already describes the parameters with 89% coverage. The description adds no parameter-specific meaning beyond the name 'cover audio', which is already apparent from the tool name. Since schema coverage is high, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool creates a Suno task for covering audio on RunAPI and lists the return values. It uses a specific verb ('Create') and resource ('Suno task'), and the 'cover audio' qualifier distinguishes it from many sibling tools, though it does not explicitly name alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives like convert_audio or remaster_audio. There is no mention of prerequisites, context, or exclusion criteria, so an agent is left without direction on tool selection.

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

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

With no annotations, the description itself must carry behavioral weight; it does state the core side effect ('Create a Suno task') and a useful outcome ('Returns a task id, status, and output URLs'). It does not disclose async/polling behavior, webhook interaction, or any limitations, but the minimal create-and-return contract is at least present.

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

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

A single front-loaded sentence communicates the core action and return values with no filler. Every word earns its place, and the parenthetical 'create mashup' reinforces the function name without bloating the text.

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

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

This is a complex tool (17 parameters, no output schema, no annotations) but the description only provides a one-line contract. Missing context includes the connection between vocal_mode and lyrics/prompt, how wait/callback_url affect the returned task, and what 'output URLs' refer to; an agent would need to reason from the schema alone for nearly everything.

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 the baseline of 3 applies: the schema already documents all parameters, including required 'upload_url_list' (exactly two URLs) and 'vocal_mode'. The description adds no parameter-level meaning, but it doesn't need to because the schema carries the burden.

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 ('Create a Suno task on RunAPI') and clarifies the specific operation with '(create mashup)', which distinguishes it from siblings like text_to_music or cover_audio. However, it doesn't explain what makes a 'mashup' task distinct from related Suno operations beyond the name.

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

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

There is no when-to-use guidance, and no sibling alternatives are mentioned. An agent must infer from the name and the 'mashup' parenthetical that this is for combining two audio files, rather than being told when to choose it over blend_lyrics, cover_audio, or text_to_music.

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 full behavioral burden. It discloses that the call returns a task id, status, and output URLs, but does not explain asynchronous behavior, polling, cost implications, required source inputs, or side effects. For a creation task with 23 parameters, this is under-disclosed.

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

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

The description is one concise sentence that leads with the primary action and then summarizes the return value. There is no wasted wording, though it is arguably too terse for the tool's complexity.

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

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

This is a complex tool with 23 parameters, one required parameter, no output schema, and no annotations. The description does not explain parameter_mode, the mutually exclusive source inputs, the wait/callback behavior, or how this relates to sibling creation tools, leaving significant 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 91%, so the schema already documents most parameters. The description itself adds no parameter-level meaning, but per the high-coverage baseline it does not need to; a 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 names a specific verb ('Create'), a specific resource ('a Suno task on RunAPI'), and an operation ('extend music'). It is clear enough to identify the tool's core action, though it does not explicitly distinguish it from siblings like cover_audio or remaster_audio.

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

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

The description gives no guidance on when to use this tool versus alternatives, no mention of requiring a source track, and no explanation of the source vs custom parameter modes. An agent has to infer usage entirely 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 provided, the description carries the burden of behavioral disclosure. It usefully states the return payload (task id, status, result), but does not disclose asynchronous behavior, required authentication, or polling semantics. This is partial disclosure but leaves significant context to 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 consists of two short sentences, front-loaded with the action and resource. Every word contributes: it states the operation, context (Suno/RunAPI), and return structure, with no redundancy.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description gives the basic purpose and return structure but lacks important context about async polling, parameter semantics, and usage boundaries. It is adequate for a high-level understanding but not fully complete for an agent to invoke correctly without inferring from schema.

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

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

The description does not mention any parameters or their roles. With 60% schema coverage, two parameters (timeout_ms, poll_interval_ms) are undocumented in both schema and description, and the description adds no semantic meaning to the prompt, wait, or callback_url 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 clearly states the action ('Create a Suno task') and the specific function ('generate lyrics'), along with the return payload (task id, status, result). It distinguishes from siblings like text_to_music or blend_lyrics by focusing on lyric generation, though it doesn't explicitly name them.

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

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

Usage is implied by the phrase 'generate lyrics' but there is no explicit guidance on when to use this tool vs alternatives, nor any exclusions or prerequisites. The description does not mention when to prefer this over text_to_music or other Suno-related 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?

The description discloses that the operation is synchronous and returns the result, which is useful behavioral context. However, with no annotations, it fails to mention potential side effects (e.g., creating a persona, consuming credits), authentication requirements, or error behavior. It is minimal but 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?

The description is a single, focused sentence that front-loads the main action and result. It is free of fluff and every word earns its place, though it could incorporate additional useful context without becoming bloated.

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

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

Given the lack of annotations, an output schema, and the tool's four required parameters, the description is notably incomplete. It does not explain what a persona is, what the returned result looks like, or any preconditions on the source task and audio IDs. An agent would have to infer these from the schema alone.

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?

All parameters are fully described in the schema (100% coverage), so the baseline is 3. The description itself does not add any semantic nuance beyond the schema, such as how parameters interrelate or what the source task/audio IDs represent in the operation flow.

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 ('Run a synchronous Suno operation') and identifies the specific operation ('generate persona'), which matches the tool name. It is not a tautology because it adds the 'synchronous' and 'RunAPI' context, but it does not explain what a persona is or how this differs from sibling tools like generate_voice.

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

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

There is no guidance on when to use this tool versus alternatives such as generate_voice or text_to_music. The description provides no context about prerequisites, intended scenarios, or conditions that would make this tool the right choice.

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

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

With no annotations, the description must disclose behavioral traits. It mentions 'synchronous' and that it returns an operation result, but does not state side effects (e.g., mutation, cost), authentication requirements, or what the operation result contains. For a tool that likely generates a cloned voice, this is a significant omission.

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

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

The description is a single sentence, which is appropriately brief, but it does not front-load the core action clearly. It prioritizes 'synchronous Suno operation' over the actual purpose, making it less useful despite being short. It is under-specified rather than concisely informative.

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 the return value in detail, but it only says 'Returns the operation result' without specifying the format or content. It also lacks information about required setup, errors, or rate limits. For a two-parameter tool, this is insufficient to guide correct invocation.

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

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

Schema description coverage is 100%, so both parameters already have clear descriptions. The tool description adds no additional context about parameter usage, format, or relationships. Baseline 3 applies because the schema carries the load and the description does not interfere.

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 verb 'Run' and a resource 'Suno operation' but is vague about what 'generate voice' entails. It does not explicitly say this tool clones a voice from an audio URL, which the schema implies. Among many sibling audio tools, it does not differentiate itself beyond the parenthetical 'generate voice', leaving ambiguity about its exact function.

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

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

No guidance is given on when to use this tool versus alternatives like text_to_music or cover_audio. There is no mention of prerequisites, use cases, or conditions under which this tool is appropriate. The agent is left to infer usage entirely from the vague 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does indicate a read-only fetch and what is returned, but it omits important async behavior such as eventual consistency, polling, and whether the result payload is empty until the task completes. This is useful but incomplete.

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 front-loaded sentence with no filler. The key action and resource appear immediately, and every word adds meaningful information.

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

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

For a low-complexity tool with two fully-documented required parameters, the description plus schema covers the essentials for invocation. The only notable gap is the missing async/polling context, but that is minor for selecting and calling the tool correctly.

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

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

Schema description coverage is 100%, so the schema already fully documents task_id and action, including the action enum. The description adds no additional meaning or format detail beyond 'suno task', so the baseline score of 3 is appropriate.

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

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

The description names a specific verb ('Fetch'), a clear resource ('a suno task'), and the exact data returned ('current status and latest result payload'). It is immediately distinguishable from the sibling tools, which are all task-creation endpoints like convert_audio, cover_audio, and text_to_music.

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. The description does not say to call this after submitting an async task, to poll until completion, or how it relates to the creation endpoints. Usage must be inferred entirely from the verb 'Fetch' and the sibling tool names.

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 needed to cover side effects, auth/cost expectations, and output semantics; it only discloses that the operation is synchronous and returns the operation result. It does not mention potential credit usage, permission requirements, or that the result is likely a raw API payload rather than parsed lyrics.

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 with no fluff; the synchronous behavior and returned result are front-loaded. The phrase 'Run a synchronous Suno operation' is slightly generic, but overall the description is efficient.

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

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

For a tool with no output schema and no annotations, this is underspecified: it lacks when-to-use guidance, expected return shape beyond 'operation result', and any behavioral caveats such as cost or latency. The schema covers inputs well, but overall call context is 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?

All parameters are already documented in the schema (100% coverage), so the baseline for this dimension is 3. The description adds no param-level detail, but it does not need to given the schema's thorough descriptions of source_audio_id and source_task_id.

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 the target operation (timestamped lyrics via Suno on RunAPI) and notes it returns the operation result, so an agent can see this is a retrieval-style operation distinct from generate_lyrics or get_task. However, the verb 'Run' is generic and the boundary of what 'timestamped lyrics' means vs other Suno operations 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?

No explicit guidance is given on when to call this tool rather than generate_lyrics or get_task. The name and parenthetical imply the use case, but the description never states a selection rule or alternatives, leaving an 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?

No annotations are provided, so the description must disclose all behavioral traits. The description mentions the return of task id, status, and URLs, implying an asynchronous pattern, but it does not explain the asynchronous behavior, polling, or whether the task is destructive. The schema hints at wait/timeout/polling, but the description does not connect these to the operational behavior, leaving the agent uninformed about side effects or execution flow.

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

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

The description is a single sentence with no filler words. It is grammatically correct and front-loads the action and resource. However, given the tool's complexity, this brevity borders on under-specification rather than true conciseness. Yet, strictly by the dimension, it is efficient and free of extraneous content, earning a high score.

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

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

With 6 parameters, no output schema, and no annotations, the description must carry substantial weight. It tells the agent what the tool does and what it returns, but leaves out crucial context such as the purpose of 'inspire music' mode, how the audio URLs are used, the significance of the model versions, and any differences from the siblings. An agent cannot effectively decide or invoke this tool without further investigation.

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

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

Schema description coverage is 67% (4 out of 6 parameters have descriptions, but timeout_ms and poll_interval_ms do not). Since coverage is not high (>80%), the description is expected to compensate, but it adds no parameter information at all. The only implicit reference is to audio_urls (as the required input), but it does not explain how they are used or their constraints (e.g., max 4 items). It falls short of the baseline 3 because the missing parameters remain 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 states a clear action ('Create a Suno task') and specific resource ('RunAPI' with 'inspire music' mode). It also mentions what it returns (task id, status, output URLs), which helps define its scope. However, it does not explicitly distinguish it from sibling tools that also generate music (e.g., text_to_music, cover_audio, create_mashup), so the differentiation is lacking.

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 guidance on when to use this tool versus alternatives. It does not state any prerequisites, exclusions, or when to prefer it over other music generation tools. The phrase 'inspire music' is ambiguous and not elaborated elsewhere. With 13 sibling tools in the same domain, this lack of contextual guidance is a major gap.

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

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

With no annotations, the description carries the behavioral burden. It discloses the interactive browser flow and the file write side effect (config.json). However, it does not mention that it may overwrite existing credentials or that it could block waiting for user input, though these are implied.

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

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

The description is a single, well-structured sentence that front-loads the action ('Authenticate RunAPI') and provides necessary details without extraneous information.

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

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

For a simple login tool with one optional parameter and no output schema, the description covers the core purpose and side effect. It lacks an explicit statement that this is a prerequisite for other tools, but that is implied.

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% (the only parameter 'force' has a description). The tool description adds no additional meaning about parameters 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?

The description clearly states the tool's purpose with a specific verb ('Authenticate'), target resource ('RunAPI'), method ('browser PKCE login flow'), and side effect (saving to config.json). It is distinct from sibling tools, none of which relate to authentication.

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

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

The description implies usage (to authenticate RunAPI) but does not explicitly say when to run it (e.g., before other RunAPI tools) or when to use the 'force' parameter. Since there are no alternative auth tools among siblings, 'vs alternatives' is not applicable.

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

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

The description mentions that it returns a task id, status, and output URLs, giving some insight into the outcome. However, it does not disclose async behavior, potential delays, error conditions, or side effects. Since annotations are absent, the description carries the full burden but provides minimal behavioral detail.

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

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

The description is a single concise sentence with no unnecessary words. It clearly conveys the purpose and primary output 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?

For a relatively simple tool, the description covers the essential purpose and return values. It lacks details such as async behavior or error handling, but given the presence of parameters like 'wait' and 'timeout_ms', the absence of such context is a minor gap. Overall, it is sufficiently complete for basic understanding.

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

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

The schema already describes several parameters (wait, model, audio_id, callback_url, source_task_id) with meaningful descriptions. The tool's description adds no extra meaning beyond the schema, and the schema coverage is high (71%), so a baseline of 3 is appropriate.

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

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

The description clearly states it creates a Suno task for remastering audio, which distinguishes it from other audio generation tools like text_to_music or cover_audio. The verb 'Create' and resource 'Suno task' are specific.

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

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

The description provides no guidance on when to use this tool versus alternatives. It only states what it does, without indicating use cases or conditions (e.g., when you have existing audio needing remastering). No explicit comparison with sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions return values (task id, status, URL) but omits critical behavioral aspects such as that this is a long-running asynchronous task, that the 'wait' parameter controls polling, or that it creates a new resource (a mutation). No safety profile, permission requirements, or side effects are disclosed, leaving significant gaps.

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

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

The description is a single sentence with no filler. It efficiently conveys the core purpose and expected output structure, achieving maximum conciseness without sacrificing essential 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?

The tool has 8 parameters including complex enums (stem_name has ~100 options), yet the description provides no context on how separation modes work, when to use 'wait' vs 'callback_url', or how output URLs are delivered. With no output schema and no annotations, the description is insufficient for an agent to confidently invoke this tool without external knowledge.

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 75% because most parameters (type, wait, stem_name, callback_url, timeout_ms, poll_interval_ms) have their own descriptions in the schema. The tool description adds nothing about parameters beyond the schema, so it does not compensate for the 25% uncovered (task_id and audio_id are minimally described but are required and self-explanatory). Baseline of 3 is appropriate since the schema handles most 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?

The description states 'Create a Suno task on RunAPI (separate audio stems)' which clearly identifies the verb (create), resource (Suno task on RunAPI), and function (separate audio stems). It unambiguously indicates what the tool does and distinguishes it from sibling tools that handle generation, lyrics, or mixing. However, it does not explicitly compare with other 'create task' possibilities, so it misses the top score.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention circumstances where separation is appropriate, nor does it explain prerequisites like needing an existing task_id or audio_id. Without any usage context or exclusionary notes, the agent is left to infer from the tool 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 burden of behavioral disclosure. It only states that a task is created and returns task id/status/output URLs, but it does not disclose async behavior, the wait default, terminal statuses, side effects, or permission requirements. This is insufficient for a task-creation tool.

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

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

The description is a single sentence that is front-loaded with the action and resource, followed by the key return values. There is no filler 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?

With 7 parameters, no annotations, and no output schema, the one-sentence description leaves major gaps: no usage context, no task lifecycle details, no clarification of wait/polling behavior, and no explanation of the output URL semantics. It is minimally viable but far from complete for an agent to use it correctly.

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

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

The schema already describes 5 of 7 parameters (71% coverage), and the description adds no additional parameter semantics beyond the tool's purpose. The undocumented timeout_ms and poll_interval_ms are not explained, and the description does not clarify how source_task_id and audio_id relate to the stitching operation, so the description provides minimal added value.

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

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

The description uses a specific verb ('Create a Suno task') with a resource ('RunAPI (stitch audio)') and states return values (task id, status, output URLs), which distinguishes it from sibling tools like cover_audio or remaster_audio. However, it does not explain what 'stitch audio' actually entails beyond the operation name.

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

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

There is no guidance on when to use this tool versus alternatives such as create_mashup or extend_music, and no prerequisites are mentioned (e.g., needing a completed source_task_id). The only usage context is the tool name, so an agent cannot confidently decide between this and sibling audio tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions returning a task id, status, and output URLs, implying an asynchronous task-based flow, but it does not disclose any side effects (e.g., cost, rate limits), how to poll or retrieve results beyond that, or any prerequisites. For a mutation tool, this is minimal disclosure.

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

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

The description is concise at two sentences with no fluff. The core purpose is front-loaded, and the return information is stated briefly. It is efficient and to the point, though it could add a bit more context without becoming verbose.

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

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

Despite having 20 parameters and no output schema, the description is extremely sparse. It does not explain the task lifecycle (e.g., how the wait parameter works, how to use callback_url, or how to interpret statuses), nor does it mention the range of vocal modes or other key options. The agent is left to rely solely on the schema, which is not sufficient for a tool of this complexity.

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

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

Schema description coverage is 90%, so the schema already documents most parameters. The description adds no parameter-specific meaning beyond what the schema provides; it does not explain how parameters relate to the text-to-music process. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the action ('Create a Suno task') and the resource ('text to music on RunAPI'), and mentions the return values. It distinguishes from siblings like text_to_sound by specifying 'music' rather than 'sound', but does not explicitly name alternatives. A clear purpose with minor differentiation gap.

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

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

No guidance on when to use this tool versus alternatives like cover_audio, text_to_sound, or extend_music. The description only states what it does, not the conditions or contexts where it is the preferred choice. This leaves the agent to infer usage from the name and 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 must carry the full burden of behavioral disclosure. It tells the agent that a task is created and returns IDs and URLs, but it omits key asynchronous traits such as polling behavior, wait semantics, webhook notifications, or the fact that the returned task may be processed asynchronously. This is insufficient for an agent to anticipate side effects or lifecycle behavior.

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

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

The description is a single sentence that gets directly to the point and front-loads the core purpose. It contains no redundant or vague filler. While it is sparse, it avoids wasted words and is easy to process.

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

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

The tool has 10 parameters, no output schema, and no annotations, so the description should provide richer context about async behavior, return format, and operational details. It only states the basics: creates a task and returns some fields. This is incomplete for an asynchronous task creation tool with multiple undocumented parameters and no output schema to guide 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?

Schema descriptions already cover 80% of parameters, so the baseline is 3. The description itself adds no parameter-specific meaning. Two parameters timeout_ms and poll_interval_ms are left undocumented in the schema and description, but the high coverage leaves the core requirements clear enough.

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

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

The description clearly states a specific action: 'Create a Suno task on RunAPI (text to sound)' with an identifiable verb, resource, and scope. It also mentions the return value (task id, status, output URLs). However, it does not distinguish this from the sibling 'text_to_music' tool, so it is not fully differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives like text_to_music, generate_lyrics, or blend_lyrics. There are no exclusion criteria, prerequisites, or contextual hints about appropriate use. The description simply states what the tool does, not when it should be chosen.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says the tool returns a task id, status, and output URLs, but does not explain whether the task runs synchronously, when polling or callbacks are needed, or how the wait and timeout parameters affect behavior.

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

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

The description is one concise sentence with no filler, and it front-loads the core action and return values. It is appropriately short, though it sacrifices useful context for brevity.

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 eight parameters, no output schema, and no annotations, the description is too thin. It omits the async workflow, the role of callback_url, the meaning of source_task_id, and when wait should be false. An agent would need to infer much of the calling convention from parameter names alone.

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 at 75%, so the schema already documents most parameters. The description adds minimal semantic value beyond framing the tool as a Suno task; it does not clarify relationships among source_audio_id, source_task_id, wait, and callback_url.

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

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

The description uses a specific verb and resource: 'Create a Suno task on RunAPI (visualize music).' This clearly identifies the operation and distinguishes it from siblings like text_to_music or remaster_audio, though it leaves some ambiguity about what 'visualize music' concretely produces.

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, nor any mention of prerequisites such as requiring previously generated audio. The description simply states what the tool does without contextualizing it against the many sibling tools.

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