Gisoo

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description still adds value beyond that by noting the call consumes no credit ('این ابزار هزینه ندارد') and by scoping the returned data, which an agent needs to decide whether calling is worthwhile.

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 resource and its returned fields. The Persian sentence is a near-exact translation of the English one, which is redundant for a monolingual reader but serves a legitimate localization purpose and costs little length.

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 by naming balance, spend, limit, and rate limits. It stops short of describing response shape or units for the limit fields, but for a zero-argument status tool this is close to sufficient.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the schema is empty and fully self-evident. Baseline 4 applies.

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

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

States a specific verb ('Show') and resource ('Gisoo AI credit balance') and enumerates exactly what is returned: balance in USD, key spend, spend limit, and rate limits. This is unmistakably distinct from every sibling (generate_image, ask_model, etc.), which are generation tools.

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

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

The line 'Free: costs nothing' implicitly signals when the tool is safe/cheap to call and hints at a pre-flight check role, but there is no explicit 'use this before/after X' guidance and no named alternatives or exclusions. Usage is inferable rather than stated.

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

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

Beyond the annotations, it discloses the key cost behavior an agent needs: the call is billed to the Gisoo credit of this key, behaves exactly like POST /chat/completions, and the USD cost is reported at the end of the answer. This is consistent with readOnlyHint=false and non-idempotency. It does not describe latency, rate limits, or failure/billing behavior on error.

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

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

Front-loaded with the action and result, then the billing constraint, then the model discovery hint — a sensible priority order. The closing Persian sentence is essentially a translation of the opening English sentence, which is redundant for a bilingual reader but justifiable for this server's audience.

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 the one return-value fact an agent needs (cost reported at end of answer) while the schema covers the prompt/context caveat. Remaining gaps are model-parameter behavior (max_tokens, temperature defaults) and what happens on insufficient credit.

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

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

Schema coverage is 60%, and the description contributes model-id examples and the pointer to list_models, which is genuinely useful for the required 'model' parameter. However 'max_tokens' and 'temperature' get no mention in either place, so the description only partially compensates for the coverage gap.

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

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

States a specific verb and resource ('send one prompt to any chat model ... get its answer') plus concrete provider names, which immediately separates it from media-generation siblings like generate_image or text_to_speech. The 'any chat model on Gisoo' framing also makes clear this is a generic dispatch tool rather than a fixed-model call.

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

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

Gives explicit motivating use cases ('second opinion or a translation') and an explicit prerequisite step: look up model ids with list_models, with examples. It does not state when to avoid this tool (e.g. multi-turn conversation or when a cheaper/free path exists), so the exclusions side is left implicit.

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?

Behavioral disclosure is unusually strong: the tool is asynchronous, returns a job id immediately, takes one to a few minutes to render, is billed per second of video, charges when rendering starts, and refunds in full on failure. It also matches the POST /videos endpoint semantics, which helps the agent understand the side effects.

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

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

The description is front-loaded with purpose and next step, then pricing and defaults. It is a bit long, and the Persian sentence repeats the English async/polling instruction, but every part remains relevant to correct invocation.

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

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

There is no output schema, yet the description fully covers the return contract: a job id, asynchronous rendering, and polling via get_video. For a non-destructive async creation tool, no essential agent-facing behavior is missing.

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

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

Schema description coverage is 100%, so each of the four parameters is already documented in the input schema. The description adds only the default model and shortest-length default, which are useful but largely duplicate schema-provided defaults.

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 — 'Start rendering a short video from a text description' — and distinguishes the tool from the sibling get_video by framing it as the job starter. An agent can immediately tell this is the video-creation entry point, not a status or image tool.

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

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

It clearly tells the agent to poll get_video with the returned id until status is 'completed', which is the key usage flow. It also supplies the default model and default shortest length. It does not explicitly exclude related tools like generate_image, but the 'short video' scope is clear enough.

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 the tool as non-read-only, open-world, non-idempotent, and non-destructive. The description adds substantial behavioral context beyond annotations: billing comes from the Gisoo credit, USD cost appears in the text, the default model and resolution are named, and text rendering is disclosed as unreliable.

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 definition is front-loaded with the core action and return format, then adds cost, model, and rendering caveats. The final Persian sentence duplicates information already provided in English, which is slightly redundant but not harmful.

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

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

The description covers purpose, return format, default parameters, cost model, billing source, model alternatives, and a key image-text limitation. With no output schema, it still clearly tells the agent what the tool returns and what tradeoffs to expect.

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 already 100%, so the baseline is 3. The description adds useful semantics beyond the schema by naming the default model and resolution, explaining that larger sizes and higher quality cost more, and pointing to list_models for model selection.

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

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

The description states a specific verb and resource: "Create one image from a text description" and specifies the return format as an MCP image in base64. This clearly distinguishes generate_image from sibling tools such as create_video, generate_music, and text_to_speech.

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 model as quick and inexpensive and directs the agent to list_models when higher quality is needed. It also gives a practical usage caveat: leave text out of the image and add it later, especially for Persian. It does not explicitly compare against every non-image sibling, but the resource-specific guidance is strong.

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

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

Annotations only declare readOnly=false, openWorld, non-idempotent, non-destructive; the description adds the material facts an agent needs — billing (paid per piece charged to the key's Gisoo credit, USD cost returned in text), latency (~1 minute), and the exact return format (base64 MP3 audio block). That is real disclosure beyond structured fields.

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

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

Front-loads the verb and output, then cost and latency — well ordered. The Persian sentence largely duplicates the English content, which is a small amount of redundancy but not harmful padding.

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 tells the agent what comes back (base64 MP3 audio block) and what the call costs in time and money. With only 2 params and full schema coverage, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so both parameters are already documented in structured form; the description merely restates prompt content categories and the default model. It adds 'optional lyrics', which the schema already covers, and no length or formatting guidance beyond maxLength.

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

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

States a specific verb+resource ('Compose one short piece of music from a description') plus the output form (MCP audio block, base64 MP3), which cleanly separates it from siblings like create_video, generate_image and text_to_speech. Scope ('one short piece') is explicit.

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

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

Gives clear selection context: short clip, default model lyria-3-clip-preview, roughly a minute, and it is paid — enough to decide between this and other media tools. It never explicitly excludes anything or names a sibling as the alternative when a longer track is needed.

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 cover read-only/idempotent/non-destructive, yet the description adds real value: the download URL only appears when status is "completed", that URL needs the same Gisoo key in the Authorization header, failed renders are auto-refunded, and the call is free. It stops short of listing the possible status values, which is the main behavioral gap for a polling tool.

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

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

Front-loaded with the verb and the sibling dependency, then the completed-status/download/auth facts in a sensible order. The bilingual rendering repeats "costs nothing" twice ("Free: costs nothing" / "این ابزار هزینه ندارد"), but the text is otherwise tight.

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 rightly explains what the response contains when status is "completed" and what happens on failure. It lacks the set of intermediate statuses an agent needs to decide whether to keep polling, which is the one thing missing for a one-parameter polling 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 coverage is 100% and the id property already documents "The job id from create_video (vid_…)", so the description adds nothing new about the parameter. Baseline 3 applies when the schema carries the semantics.

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

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

States a specific verb and resource ("Check a render started with create_video") and ties itself directly to the create_video sibling, so an agent can tell it apart from create_video and the other generation tools. The Persian sentence reinforces the same purpose without contradiction.

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 clear: call this after create_video to poll a render, and the download endpoint plus auth requirement are given for the next step. It does not explicitly say when not to use it or what to do while status is still pending, but the sequencing is unambiguous.

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

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

Annotations already declare readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds genuinely new context: results are limited to models the key is permitted to use, prices are public USD figures, and the call is free ('costs nothing'). It does not describe pagination or truncation 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 English portion is front-loaded and efficient: capability, filters, cost, then the chaining hint. The trailing Persian sentence mostly duplicates the English content, which adds bulk without new information, though it plausibly serves localization.

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 usefully states what comes back (model list with public USD prices, and an `id` field to reuse). For a simple read-only list tool that is nearly complete; only the `limit`/pagination dimension and full return shape are left unstated.

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

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

Schema coverage is 67%; `type` and `search` are already documented in the schema, and the description largely restates the enum values rather than adding semantics. The third parameter, `limit`, is unmentioned in both description and schema description, so the description does not compensate for 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 ('List the AI models'), scopes it to what 'this Gisoo key may call', and adds that prices are returned. It is instantly distinguishable from the sibling tools, which all invoke models rather than enumerate 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?

Explicitly routes the agent onward: 'Use the returned `id` as the `model` argument of the other tools', which tells it when this tool is a prerequisite step. Filter usage ('by type ... and/or a search word') is also described. It stops short of naming when-not to call it or which sibling to prefer once an id is known.

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

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

Beyond annotations, the description discloses that the call is paid from the Gisoo credit of the key, comparable to POST /audio/speech, and that the USD cost is included in the text. It also explains the output shape (MCP audio block, base64, MP3 by default), which is important behavioral context for a paid generation tool.

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

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

The English portion is front-loaded and efficient, covering limits, output type, model default, and cost. The Persian sentence largely repeats the conversion and credit-deduction points, adding slight redundancy but remaining short.

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 usefully explains that audio is returned as an MCP audio block and notes the default format. It also covers payment and cost transparency. Minor gaps remain around voice/instructions behavior, but the core invocation context is 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 80%, so the schema already documents most parameters. The description reinforces the 2000-character limit, default model, and MP3 default, and adds that input may be Persian or English, but it does not add much beyond what the 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 states a specific verb and resource: converting up to 2000 characters of Persian or English text into spoken audio. It also specifies the return format (MCP audio block, base64, MP3 by default) and default model, making the tool's function immediately clear and distinguishable from sibling generation tools.

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

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

It gives clear usage context: text-to-speech for up to 2000 characters, with Persian/English support and default model behavior. It does not explicitly compare against alternatives like generate_music or ask_model, but the generation context is clear enough for an agent to select it.

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