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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safe-read profile is covered. The description adds that the result reveals the auth mode (API key vs anonymous free tier), which is useful context, but says nothing about freshness/caching of the credit count or whether the call itself costs credits.

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; both the identity and credit facets are stated immediately and nothing is wasted.

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

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

There is no output schema, so the description must carry the return-value burden, and it does name the two returned facts (account identity and remaining credits). It stops short of describing the exact shape or when the identity would differ, leaving a small 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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate beyond what the empty schema already conveys.

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 the resource (the server's account identity) and the two things it returns: the acting account (API key vs anonymous free tier) and remaining credits. This is specific and a reader can distinguish it from the generation-oriented siblings, though it doesn't explicitly contrast itself with any sibling.

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

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

Usage is only implied: an agent infers it should call this to check identity or credit balance before generating. There is no explicit when-to-use, when-not-to-use, or named alternative (e.g., 'check this before generate_image to avoid credit failures').

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds useful behavioral context beyond that: results are curated apps with tuned preset looks and real example outputs, and an empty query switches the call from search to trending listing. No pagination or result-field detail, but the added context is genuine.

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 sentences, front-loaded with purpose, then query examples, then the follow-up workflow. 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?

For a 3-parameter, no-output-schema search tool this is nearly complete: the agent knows what it searches, how to phrase queries, what the results conceptually are, and which siblings to invoke next. Minor gaps are the undocumented limit default/cap and the concrete shape of returned app records.

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% (kind and query documented, limit not). The description reinforces query semantics with natural-language examples mapped to the image/video/music categories covered by the kind enum, which helps the agent formulate calls. It adds nothing for limit, keeping it short of a 5.

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

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

States a specific verb (search) and resource (Tanvo's ready-made AI apps), enumerates the content categories, and gives five concrete example queries that make the scope unmistakable. An agent can distinguish it from generate_image or list_models without opening any schema.

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

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

Explicitly routes the agent through the workflow: 'Use get_app for the looks, then generate_from_app to run one,' and the query parameter notes that an empty string lists trending apps. Clear context and named alternatives, though it does not state when *not* to use this tool (e.g. for raw model selection via list_models).

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

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

Annotations only declare openWorldHint, so the description carries the full behavioral burden and does so well: it discloses credit charging based on the look model, refunds on failure, the auth requirement (TANVO_API_KEY), and that the look's tuned prompt and model are used. These are non-obvious operational facts an agent needs before invoking.

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 dense sentences, front-loaded with the core action and example, then constraints (ordering, prompt/model, cost/refund, auth). No filler or restated name/title.

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

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

There is no output schema, and the description covers cost, refunds, auth, ordering, and defaults well enough to call the tool. It leaves one gap: it doesn't explain the async path when wait=false (presumably retrieving via get_generation), which matters given the video default is not to wait.

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

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

Schema description coverage is 100%, so the baseline is 3; the description adds real meaning beyond the schema by explaining that photos are ordered according to the app's inputs (see get_app) and that `details` is a personal touch woven into the prompt. That clarifies usage of two parameters in ways the schema does not.

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?

Specific verb+resource ('Run one of Tanvo's apps with one of its looks on the user's photos') with a concrete example that clarifies the distinction from the generic generate_image sibling. An agent can tell this is preset/look-driven generation rather than free-form prompting.

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?

Routes the agent to get_app for input ordering and look ids, and conditionally to find_apps via the schema ('App slug from find_apps'), plus a note that TANVO_API_KEY is needed unless the free engine is used. It never states when NOT to use this tool versus generate_image/generate_video, so it is clear context without explicit exclusions.

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

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

Annotations only declare openWorldHint, so the description carries the behavioral burden and does it well: it discloses the return form (inline when small, plus URL), the authentication requirement (TANVO_API_KEY for non-free models), and the billing behavior (credits charged per run, refunded on failure). That is exactly the cost/auth/error context an agent needs before invoking.

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 with zero filler, front-loaded with the core capability and mode switch before dropping into auth and billing details. Every sentence carries distinct 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 no output schema, the description correctly takes on the return-value explanation (inline image plus URL) and covers setup and cost. The one gap is async behavior: `wait` defaults to true, but the description never tells the agent what to do when wait=false (poll get_generation), which is a meaningful omission for a long-running generation tool.

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

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

Schema description coverage is 88%, so the schema already documents prompt, images, model, aspect, resolution, save_to, wait and format. The description adds one genuinely new semantic — that `images` turns the call into an edit/combination — but contributes nothing about `wait`, `save_to` defaults, or aspect/resolution constraints beyond the schema. Baseline 3 applies 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?

The opening clause names a specific verb pair (generate/edit) and resource (image), and explicitly states the condition that switches modes: an edit or combination 'when `images` are given.' It is immediately distinguishable from siblings like generate_video, generate_music, and generate_from_app.

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 two usage modes via the `images` condition and notes the free-tier model, which is useful routing context. But it never says when to prefer this over siblings (e.g. generate_from_app) nor names list_models as the way to discover valid model ids, and it is silent on the non-blocking path (wait=false, then get_generation).

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

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

Annotations supply only openWorldHint=true, so the description carries the behavioral load — and it delivers: credit cost ('60 credits a run'), auth requirement ('needs TANVO_API_KEY'), and what a run actually produces (two takes, each an MP3 with cover art, title, and sung lyrics). It doesn't cover async retrieval when wait=false, but cost and auth disclosure is substantive context beyond the annotations.

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

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

Three sentences, front-loaded with what the tool produces before the mode table and the cost/auth constraints. Every clause carries information — output format, mode semantics, pricing, credential requirement — with no filler or restatement of the name.

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

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

With no output schema, the description correctly compensates by describing the return (two takes, MP3, cover art, title, lyrics) and adds cost/auth/mode detail. The one gap is that it never mentions the async path — when wait=false the agent presumably needs get_generation to fetch results — which matters for 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 coverage is 71%, and the description adds real meaning on the highest-stakes parameter by explaining how prompt and mode interact, which the enum alone cannot convey — the same string means a one-line brief in Describe but full tagged lyrics in Lyrics. The remaining params (wait, save_to, title, vocal) are left to the schema, which is acceptable at 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 ('Makes two takes of a song on Suno V6') plus the concrete output (two MP3s with cover art, title, and lyrics as sung). This clearly distinguishes it from siblings generate_image, generate_video, and generate_from_app without needing to 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?

The mode breakdown ('Describe' = one-sentence prompt, lyrics written for you; 'Lyrics' = your lyrics with [Verse]/[Chorus]/[Bridge] tags; 'Instrumental' = prompt describes the sound) tells an agent exactly how to choose the mode and what to put in prompt for each. There are no explicit exclusions or routing rules versus sibling generation tools, so it stops short of a 5.

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

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

With only openWorldHint annotated, the description carries the burden and delivers useful traits: generation takes one to several minutes, the call returns immediately with an id by default, and it needs TANVO_API_KEY. It stops short of disclosing cost or the exceptions to the default async return.

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 packed sentences with zero filler; the capability, the latency/default behavior, and the auth requirement are all 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?

No output schema exists, yet the description covers the essential return contract (id for get_generation) and auth. It omits how save_to affects returns, but the schema covers that parameter fully.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the image/end_image pairing semantics (start frame vs ending frame), which the schema largely already conveys per-parameter.

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+resource ('Text to video') and clarifies the alternate mode ('animate a still when `image` is given'), which cleanly differentiates it from the sibling generate_image tool without requiring a schema 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?

It explains the default behavior and routes the agent onward ('by default this returns at once with an id for get_generation'), which is clear usage context. It does not explicitly contrast when to choose this over generate_image or generate_from_app, so it falls short of full when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so safety is covered. The description goes further by disclosing the actual payload contents (preset looks with example outputs and underlying prompts, model, browser link), which is meaningful context beyond the structured fields, though it says nothing about behavior for an invalid slug.

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 sentence, front-loaded with 'One Tanvo app', with the returned fields listed compactly. It is appropriately sized for a read tool, though the parenthetical about example output and prompt is slightly dense.

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

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

With no output schema, the description carries the burden of explaining return values and does so thoroughly, covering all major response components. Only the failure mode for an unknown slug is 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 description coverage is 100% and the single 'app' parameter is documented as 'App slug from find_apps', so the schema carries the load. The description adds no syntax or format detail beyond restating that it concerns one app; 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 the resource ('One Tanvo app') and enumerates exactly what it returns: photos, preset looks with example output and prompt, model, and browser link. An agent can distinguish it from find_apps (search) and get_generation (single generation), though the verb is 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?

There is no explicit when-to-use sentence or named alternative, but the content listing implies a detail-fetch operation for an app the agent already knows about. The workflow link (slug comes from find_apps) lives in the schema parameter description, not the tool description, so guidance 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?

Annotations already mark it read-only and open-world. The description adds that this observes an earlier-started run and should be polled for videos. It does not disclose return shape, status transitions, pagination, or whether wait blocks, leaving behavior largely to schema and 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?

One sentence, front-loaded, with a parenthetical that adds polling guidance. No filler, though the structure is minimal and the parenthetical could be slightly clearer.

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 polling tool with no output schema, the description identifies what is returned (status, outputs) and when to poll. However it omits what id refers to, expected status values, and how wait/save_to interact, leaving gaps an agent must infer.

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 mentions none of the three parameters. id is undocumented in both schema and description; wait and save_to have schema text but the description adds no meaning beyond that. It fails to compensate for the missing id semantics.

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

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

States a specific resource (a generation run) and action (retrieve status/outputs) in a short sentence, and distinguishes itself from siblings like generate_video by being the polling endpoint. It stops short of explicitly naming alternatives, so it is clear but relies on the parenthetical for 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?

Includes an implicit when-to-use cue: poll this after starting a run, specifically for videos. It does not identify alternatives or state when not to use it, so guidance is present but incomplete.

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

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

Annotations already declare readOnlyHint and openWorldHint, so safety is covered. With no output schema, the description usefully carries the return-content burden, disclosing that options (aspect, resolution, duration, format, audio), reference-image capacity, free-tier eligibility and default credit cost are all included — an agent knows exactly what it gets back.

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 dense sentence with the scope ('Every image, video and music model') front-loaded before the payload list. The parenthetical field enumeration is long but earns its place given the absence of an output 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 parameterless, read-only catalog call with no output schema, the description covers the return payload thoroughly. It could note whether the full catalog is returned at once or whether the kind filter is required for reasonable performance, which is the only remaining 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?

Only one parameter (kind) exists and schema description coverage is 100%, so the enum values and their meaning are fully documented in the schema. The description adds nothing about filtering behavior, 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?

The description names the resource precisely (image, video and music models) and enumerates the facets returned, which cleanly separates it from the generate_* siblings. The verb is only implicit (the title supplies 'List'), and the sentence is framed as a return-value inventory rather than an action, 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?

There is no statement of when to call this versus alternatives, nor any prerequisite or exclusion. An agent can infer it is a discovery/catalog call to run before generate_image or generate_video, but that routing is left entirely 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?

readOnlyHint=true is consistent with returning a link, and the description adds what the link is preconfigured with, which is genuine value beyond the annotation. It does not disclose whether the link is shareable, expiring, or auth-bound, nor whether the tool launches a browser itself versus returning a URL for the agent to 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?

Two sentences, front-loaded with what the tool yields before the usage condition. Slightly dense in the middle clause, but every sentence carries content and none is redundant with the title or schema.

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

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

No output schema exists, so the description must carry the return contract, and it only partially does: 'A link' is stated, but it is ambiguous whether the tool opens the browser or returns a URL the agent should surface. With 5 optional parameters and a prefill contract, a sentence on precedence between app/look and kind/model would close the remaining gap.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds relational meaning the schema lacks: 'app on a chosen look' and 'studio with a model and prompt filled in' explain how the parameters combine into the two distinct modes. It stops short of explaining behavior when conflicting params (e.g. both app and kind) are supplied.

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

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

States a specific resource (a link that opens Tanvo preconfigured) and enumerates the two modes: an app on a chosen look, or a studio with model/prompt prefilled. It is distinguishable from the generate_* siblings because it produces a UI link rather than a generation, though it never names those siblings explicitly.

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

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

Gives a clear positive trigger: 'Use it when the user wants to upload photos and tweak settings themselves, or has no API key.' That condition implicitly routes the agent away from generate_image/video/music, but no alternative is named and no explicit when-not case is stated.

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