APICK Convert

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

The description discloses useful behavioral details beyond the annotations: it accepts strings with a 'data:image/type;base64,' prefix and mentions a per-call point cost. The readOnlyHint annotation is consistent with a decoding operation. It does not mention error behavior or output delivery, but the core behavior is transparent.

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

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

The description is short and front-loads the core action, then adds the prefix allowance and cost note. The English and Korean sentences repeat the same meaning, which is slightly redundant, but the overall size is still appropriate and every distinct piece of information is useful.

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 one-parameter utility with annotations, the description provides enough context: what the tool does, input tolerances, and cost. It lacks explicit output format or failure behavior, but since the return is described as an image file, this is reasonably complete for the tool's 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?

The schema already covers 100% of the single parameter's meaning, including the accepted data-prefix format. The description repeats essentially the same information without adding new semantic detail, 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 states a precise transformation: 'Decode a base64-encoded image string back into an image file.' The verb is specific, the resource is clear, and no sibling tool performs base64 decoding, so the purpose is unambiguous and well 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?

The intended use is implied—decode a base64 image string when you need the original image file—but there is no explicit when-to-use or when-not-to-use guidance, nor any named alternatives. It is enough for a simple, unique utility but does not actively guide 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?

The annotations already declare readOnlyHint=true and openWorldHint=false, and the description does not contradict them. It adds useful behavioral context beyond annotations: it converts and returns the PDF, accepts only DOCX input, and costs 80 points per call.

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

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

The description is short and front-loaded with the English action, but the Korean sentence largely repeats the same conversion statement. The cost note and format restriction are useful, but the bilingual redundancy makes the description less concise than it could be.

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 one fully documented parameter, no nested objects, and no output schema, the description plus schema is complete. The agent knows what input is required, what the tool returns, what restrictions apply, and what the call costs.

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 docx_url parameter already documents the downloadable HTTPS URL, allowed MIME type, and 25MB limit. The description adds no meaningful parameter semantics beyond reaffirming the DOCX-only restriction.

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 (convert), a specific source resource (DOCX), and a specific target format (PDF). This makes it easy to distinguish from reverse operations like pdf_to_docx and other conversion tools such as html_to_pdf.

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 explicit when-to-use or when-not-to-use guidance and does not name alternatives for reverse conversion. The only guidance is the input restriction that exactly DOCX files are allowed, which is a constraint rather than usage-direction 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 include readOnlyHint=true, which is consistent with a tool that returns a transformed PNG rather than modifying the source. The description adds format support (PNG, JPEG), adjustable parameters, and a per-call point cost, which is useful context. It does not explain potential failure modes, image size limits beyond the schema, or whether the returned PNG is a download URL or base64 payload, so it stays at a moderate level.

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

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

Two sentences plus a short cost note. It is compact and front-loads the core action. The cost note is extra but relevant for agent decision-making. Slightly redundant with schema field descriptions, but not 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?

For an image transform tool with a 100% documented schema and readOnlyHint, the description covers the essential behavior, supported formats, and adjustable attributes. It does not describe return format details, but with no output schema and a simple visual transformation, the gaps are minor. Sibling differentiation is sufficient via the image/PDF distinction.

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

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

Schema description coverage is 100%, so every parameter is already documented with type, range, and default. The tool description repeats the general concepts of size, color, opacity, density but adds no syntax or behavioral detail beyond the schema. Baseline 3 is appropriate.

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

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

The description uses a specific verb ('Draw') and a concrete resource ('a visible text watermark across an image'), and it states the output is a PNG image. It is clearly distinct from draw_watermark_pdf, which is a sibling, because it specifies image files. It could name the sibling explicitly, but the resource difference is already clear.

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

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

The description implies usage for adding visible text watermarks to images and lists supported image formats and adjustable attributes. It does not explicitly state when to use this tool over draw_watermark_pdf or set_watermark, but the image-vs-PDF distinction is clear from the description and sibling name. No explicit exclusions or alternative routing, but enough context for a typical agent.

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 provide readOnlyHint=true, and the description is consistent with it by stating a new artifact is returned ('삽입한 PDF 를 반환합니다') rather than implying mutation of the source. Beyond the annotation, the description adds useful behavioral facts: adjustable properties, PDF-only restriction, and a 10-point-per-call cost. No contradiction exists between the write-looking action ('draw') and the read-only hint because the tool returns a processed copy.

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 compact and front-loaded: purpose first, then output behavior, customization options, format constraint, and cost. The only waste is that the Korean sentences largely restate the English ones, creating minor bilingual redundancy, but every substantive fact 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 9 parameters, 2 required, full schema coverage, and an annotation covering the safety profile, the description covers the essentials: purpose, output (returns watermarked PDF), customization, and input restriction. Gaps are minor — no explicit mention of failure modes for invalid URLs or guidance on which sibling to use for non-PDF files — but these are partially mitigated by the schema and tool-name context.

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

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

Schema coverage is 100%, with every parameter already carrying ranges, defaults, and units (e.g., angle 0~360 default 35, density 100~200 default 150). The description's summary of '글자 크기·색상·투명도·각도·밀집도·적용 영역' (font size, color, opacity, angle, density, application area) provides a helpful conceptual grouping but adds no factual meaning beyond the schema, so the high-coverage 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 opens with a specific verb+resource: 'Draw a visible text watermark across every page of a PDF file.' It names the resource (PDF), the action (draw visible text watermark), and scope (every page). This clearly differentiates the tool from siblings like draw_watermark_image, which applies watermarks to images instead.

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 by stating the operation ('insert a text watermark across all pages of a PDF') and adds constraints ('PDF 형식의 파일만 허용됩니다' — only PDF files allowed) and cost ('[호출당 10포인트]'). However, it never explicitly routes to alternatives such as draw_watermark_image for non-PDF inputs, so an agent must infer the boundary from tool names rather than from this 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?

Annotations declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral context beyond that: supported input formats, JPEG output, and per-call cost. It does not mention edge cases such as when no face is found, but that is a minor gap for a read-only transformation.

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 the core action, and the Korean sentences add non-redundant details such as JPEG return format, supported image formats, and cost. There is no filler or unnecessary repetition.

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

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

For a simple two-parameter read-only tool, the description covers the essential operation, input formats, and return format. Minor omissions are an explicit alternative to face_detection and behavior when no face is detected, but with full schema coverage this is nearly complete.

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

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

Schema coverage is 100%, and the schema already documents image_url requirements, allowed MIME types, size limit, threshold range, default, and semantics. The description adds no parameter-specific meaning beyond the schema, so the baseline 3 applies.

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

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

The description names the exact operation ('detect faces') and result ('blur/mosaic them') plus the JPEG output format, which clearly distinguishes it from sibling face_detection and other image tools. The Korean sentence reinforces the resource and output without ambiguity.

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 about when to choose this tool over alternatives such as face_detection or image_edit. The privacy-blurring use case is implied but never stated as a selection criterion or contrasted 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds meaningful behavioral context beyond the annotations: the tool returns a JSON result, is robust to partial image modification ('높은 확률로 워터마크를 확인'), supports common formats, and carries a per-call cost of 10 points — a practical operational detail agents benefit from. No contradiction with annotations exists.

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 tight and purpose-front-loaded: one clear directive sentence followed by three high-value specifications (JSON return, robustness, format support) and a cost note. Every sentence earns its place. Minor redundancy exists from stating the same idea in both English and Korean, but the whole remains compact and scannable.

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, single-parameter read tool with readOnlyHint=true and full schema coverage, the description is nearly complete: it covers return format (JSON), supported formats, robustness characteristics, and cost. With no output schema present, it would benefit from a brief note on the JSON response structure, but that gap is minor for a tool returning a watermark code.

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 single image_url parameter is already fully documented (downloadable https URL, allowed MIME types, 50MB cap). The description's mention of PNG/JPEG support is consistent with but less specific than the schema, adding minimal new meaning. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description opens with a specific verb+resource pair: 'Read the invisible watermark code embedded in an image.' It clearly states the tool's function (read/query, return as JSON) and is naturally distinguished from closely related siblings like set_watermark (write operation), draw_watermark_image, and draw_watermark_pdf (visible watermark drawing). The bilingual phrasing reinforces rather than obscures the purpose.

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

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

Usage context is implied rather than explicit: the read-vs-set/draw contrast with sibling names signals when to pick this tool, and the description adds practical conditions (works on partially modified images, supports PNG/JPEG, costs 10 points per call). However, there is no explicit 'when to use' statement, no named alternative, and no exclusion guidance such as 'use draw/set_watermark to embed watermarks instead.'

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 operation read-only, and the description adds the per-call point cost and confirms the output is a PDF file. It does not mention rendering limitations, CSS support, or how the file is returned, but for a simple conversion tool the key behavioral context is 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?

The description is short, front-loaded with the action, and includes a useful cost note. The Korean sentence largely duplicates the English opening, which is minor redundancy in an otherwise tightly worded 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?

For a simple two-parameter conversion tool, the description plus schema is sufficient: input shape, optional pagination, and output type are covered. It could be more complete by describing the response format, but the absence of an output schema makes that a modest gap.

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

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

Schema description coverage is 100%, so the html and pagination parameters are already documented. The description only restates that an HTML string is the input and adds no new semantic detail about parameters.

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

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

The description uses a specific verb and resource: 'Render HTML code into a PDF file,' and further clarifies the input is an HTML string returning a PDF. This clearly separates it from sibling converters like docx_to_pdf and pdf_to_image.

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 makes the primary use case explicit: provide HTML code as a string to receive a PDF, which implies it is not for URL-based conversion or other document formats. It does not explicitly name when-not-to-use or alternatives, so it stops short of full routing 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?

The annotations already mark the operation as read-only, and the description adds useful context by stating that a converted Excel file is returned and that each call costs 1 point. It does not document limits or error behavior, but these are minor for a simple conversion tool with readOnlyHint set.

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 short and front-loaded with the core purpose, followed by input-format guidance and cost notice. The Korean sentence repeats the English statement, adding minor redundancy, but the overall structure remains efficient and scannable.

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 two-parameter conversion tool, the description covers purpose, input shapes, return behavior, and cost. There is no output schema, but the output type is explicit in the description. Minor details like default sheet_name or row-count validation are already partially covered by the schema.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds value by giving concrete examples of the two supported data_list formats and clarifying that the output is an XLSX file; sheet_name semantics are left to the schema, which is sufficient.

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 (convert) and resource (JSON to Excel/XLSX), and states that the result is returned. It also names the supported input shapes, which makes the tool's function unambiguous and distinguishes it from file-conversion siblings like docx_to_pdf or pdf_to_image.

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 conveys when to use the tool: whenever JSON data needs to be converted to Excel. It also gives concrete guidance on accepted data_list formats and mentions the per-call cost. It does not explicitly name alternative tools or state when not to use it, but no direct sibling performs this conversion.

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 the description adds genuine operational context beyond that: merge order is preserved ('순서대로'), only PDF inputs are accepted, and each call costs 2 points. This does not contradict the annotations since merging returns a new file without mutating the inputs. The only gap is the unspecified return delivery format (URL vs. binary).

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

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

Four short sentences with the core action front-loaded in both English and Korean. The bilingual restatement is mildly redundant, but the Korean variant contributes unique details (ordering, return behavior) and the cost note is compact and useful.

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 2-parameter tool with 100% schema coverage, readOnly annotation, and a clear purpose, the description covers the essentials including input constraints and cost. The main omission is the output format since no output schema exists, but the statement '하나의 PDF 파일로 합쳐 반환합니다' partially addresses 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 description coverage is 100%, with both parameters fully documented as downloadable https URLs accepting application/pdf up to 25MB. The description's format restriction largely restates the schema, so it adds little parameter meaning beyond the baseline.

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+outcome: 'Merge two PDF files into one,' reinforced by the Korean '두 개의 PDF 파일을 순서대로 하나의 PDF 파일로 합쳐 반환합니다.' This is unambiguously distinguishable from sibling converters (pdf_to_docx, pdf_to_image, docx_to_pdf) and clearly describes the combining operation.

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

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

Usage is implied by the purpose statement (combine two PDFs → call pdf_merge), and constraints like 'PDF 형식의 파일만 허용됩니다' (only PDF format allowed) and the 2-point cost give partial applicability guidance. However, no explicit when/when-not conditions or alternative tools are named, so routing decisions are left 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?

Annotations declare readOnlyHint=true and openWorldHint=false, and the description adds the operational cost of 30 points per call, which is useful beyond the schema. It also says the PDF is converted and returned, but it does not describe failure behavior, output representation, or other side effects; the readOnlyHint is not contradicted because no persistent state modification is claimed.

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 compact and front-loads the core action before the cost note. The Korean sentence is partly redundant with the English opening but also adds the explicit 'returns' behavior in a bilingual interface, so the structure remains 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 single-parameter conversion tool with no output schema, the description covers the conversion semantics, the input restriction, and the cost, which is most of what an agent needs. It lacks an explicit return-format statement and alternative routing, but those are minor given the tool's simplicity and the complete 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?

With 100% schema description coverage, pdf_url is already documented as a downloadable HTTPS URL with application/pdf content type and a 25MB limit. The tool description adds no parameter-level meaning beyond repeating the PDF restriction, 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 opens with an explicit verb and both target formats: 'Convert a PDF file to a DOCX (Word) file,' and the Korean sentence repeats the same transformation. This makes the conversion direction unambiguous and separates it from the sibling docx_to_pdf without needing to inspect the schema.

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

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

The conversion direction strongly implies when the tool should be used (PDF input, DOCX output), but the description never states it explicitly or names alternatives such as docx_to_pdf for the reverse direction. It only gives the input constraint that PDF files are allowed, which is a prerequisite rather than usage 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 provide readOnlyHint=true and openWorldHint=false, so the safety profile is known. The description adds useful behavioral context beyond that: only PDF inputs are accepted, every page becomes a PNG, and the result is returned as a ZIP archive. It also notes the per-call cost, and it does not contradict 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?

The core English sentence is front-loaded and precise, and the cost note is a useful addition. The Korean sentence largely repeats the English content, creating minor redundancy, but the overall description is still compact and easy to scan.

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

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

With one required parameter and full schema coverage, the description communicates the essential contract: input a PDF via URL, output a ZIP containing per-page PNG images. It does not detail ZIP structure or failure behavior, but for a simple single-parameter conversion tool this is sufficiently complete.

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

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

Schema coverage is 100%, and the pdf_url parameter already documents the downloadable https URL, allowed application/pdf format, and 25MB limit. The tool description only restates the PDF-only constraint and adds no deeper semantics about URL handling, errors, or output naming. This stays at the baseline for 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 states a specific verb and resource: 'Convert each page of a PDF file to PNG images, returned as a ZIP archive.' This clearly differentiates it from sibling conversion tools like pdf_to_docx and pdf_merge. The Korean line reinforces the same meaning without ambiguity.

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 use case is implied: use this when PDF pages are needed as PNG images in a ZIP archive. However, the description does not explicitly mention when not to use it or how it compares to alternatives such as pdf_to_docx or pdf_merge. The only explicit constraint is that only PDF files are allowed.

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 provide readOnlyHint=true, and the description does not contradict it; it returns a new PNG rather than mutating the original. The description adds useful behavioral context beyond the annotation: the watermark is invisible, robust to partial transformations, supports multiple formats, and costs 10 points per call. It does not detail failure modes, but the addition of cost and robustness is meaningful.

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 compact and front-loaded with the main action in English, followed by Korean translation and key operational facts (return type, robustness, supported formats, point cost). Every sentence contributes meaningful information; the only slight inefficiency is the bilingual repetition of the same core statement.

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 two simple parameters and no output schema, the description covers the input domain well and states the output is a PNG image. However, it does not specify how the returned image is delivered (e.g., URL, base64, file path) or whether the operation is synchronous. Given no output schema exists, a more explicit return-value description would complete the picture.

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

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

Schema coverage is 100% with descriptions for both parameters, so the baseline is 3. The description adds valuable semantics beyond the schema: code is described as a numeric watermark code with a specific intended range (1 ~ 21,767,823,359), and image_url is clarified with allowed MIME types and a 50MB size limit. A minor inconsistency exists between the schema's broad min/max and the description's restricted range, but the description still provides actionable detail.

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

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

The description opens with a specific verb and resource: 'Embed an invisible watermark code into an image' and clarifies the return type (PNG image). This makes the tool's function clear and conceptually distinguishes it from get_watermark (extraction) and draw_watermark_image/PDF (likely visible watermark drawing), though it does not explicitly name or contrast siblings.

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

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

The description gives implied usage context: it is for inserting an invisible, robust watermark into common image formats, and notes that detection works even after partial image modification. However, it provides no explicit guidance on when to prefer this tool over sibling draw_watermark_image or get_watermark, nor any 'when not to use' conditions.

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=false, covering the safety profile. The description adds useful behavioral context beyond annotations: supported audio formats, that the result is returned as JSON, and the cost of 50 points per call. It does not mention authentication or rate limits, but the added cost and format details are substantive.

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 the core action and efficiently lists supported formats, return type, and cost. The bilingual repetition adds some redundancy but remains acceptable for a service likely targeting both English and Korean users.

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

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

No output schema exists, but the description notes that the converted text is returned as JSON, which fills that gap. Combined with annotations covering the safety profile and the schema covering all parameters, the definition is complete enough for an agent to call the tool correctly, though it lacks routing guidance.

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 input schema already documents all three parameters in detail. The description lists common audio formats, but this overlaps with the schema's allowed MIME types and does not add meaning for the required audio_url, language, or artifact_filter parameters. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: 'Convert a speech audio file to text (STT)'. It clearly distinguishes the tool from siblings like OCR (image-to-text) and TTS (text-to-speech), so an agent can identify its role without opening the schema.

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

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

The description explains what the tool does but provides no guidance on when to use it versus alternatives. There is no explicit mention of when-not to use it, what kinds of inputs are appropriate, or how it differs from sibling tools such as youtube_subtitle or video_to_mp3.

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 the coarse profile (not read-only, not destructive, not idempotent, open-world). The description adds material context the annotations do not: normalization is on by default with a 2,000-character cap and a skill fee, and disabling it does not change the MP3/ASS output structure. That is genuinely additive, though it is silent on whether this is an async job that must be polled.

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

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

The purpose sentence is front-loaded and efficient, but the trailing bracket is a dense, run-on pricing formula (token cost x FX x 1.4 + skill fee) that is hard to parse and partially duplicates the normalize_text fee already stated earlier.

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 14-parameter, nested-object tool with no output schema, the description covers cost and normalization limits but omits the return contract: it never says the call produces a job handle consumed by tts_jobs_status/tts_jobs_result, which is the key thing an agent needs to chain the workflow.

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

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

Schema description coverage is 100% across 14 parameters, so the schema already carries the per-parameter detail and the baseline is 3. The description adds only a little beyond it (the 2,000-character normalization cap and the text-vs-utterances alternative), so it does not rise above baseline.

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 (전달/submit voice, style, text or utterances) and a specific resource (Gemini 3.8 Flash-Lite TTS), which separates it from the tts_openai_create sibling. The purpose is clear despite the pricing bracket adding noise at the end.

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 pick this over tts_openai_create, tts_quote, or the tts_jobs_* siblings. The only conditional guidance is about the normalize_text default and its fee, which is parameter behavior rather than tool selection guidance.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description goes beyond that by disclosing visibility scope (public voices only), a conditional-field rule (age appears only when separately verified), and cost (free) — all information not present in 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 short sentences, each carrying distinct information (scope, caveat, pricing), with the core action front-loaded. No filler.

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

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

With no output schema, the description must convey the shape of the result, and it does list the returned attributes (voice set, gender, tone, verification time, conditional age). It stops short of describing ordering, count, or format, but is adequate for a no-arg listing 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?

Zero parameters, so there is nothing for the description to disambiguate; baseline is 4. No parameter-related noise is introduced.

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 (조회/retrieve) and resource (Gemini TTS voices), and enumerates what the listing contains: public basic/extended voices, gender, official tone, verification timestamp. It does not explicitly differentiate itself from siblings like tts_gemini_create or llm_models, but the resource is unambiguous.

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

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

No indication of when to call this versus picking a voice elsewhere, nor any workflow hint such as 'call before tts_gemini_create'. The '[무료]' tag hints at cost but does not function as usage 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 flag destructive=true and idempotent=false, but the description adds genuinely non-structured behavior: unpaid reservations are released, already-consumed paid processing is still settled, there is no additional charge, and a closing connection is not a cancellation. These billing/state semantics go well beyond the annotation layer.

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 tight sentences: purpose first, then billing effect, then the connection caveat, then the charge note. Every sentence carries distinct information with no repetition.

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

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

For a single-parameter cancellation action with no output schema, the description supplies the job states affected, the billing outcome, and the footgun (connection close ≠ cancel). Nothing essential to calling 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% and the single job_id param is fully documented in the schema (32-char hex, '취소할 32자리 ID'). The description adds no extra syntax or format meaning beyond the schema, so the baseline 3 is correct.

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

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

States a specific verb (취소 요청/cancel) on a specific resource (waiting/processing TTS 작업), and scopes it to two job states. This cleanly separates it from siblings like tts_jobs_retry, tts_jobs_status, and tts_jobs_result 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?

Gives clear context for when it applies ('waiting 또는 processing TTS 작업') and adds the negative constraint that merely closing the connection does not cancel. It does not, however, name an alternative sibling for related needs (e.g. retry vs cancel), so it stops short of full when/where-not routing.

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

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

Annotations already declare readOnlyHint=false, so mutation is known; the description goes further with genuinely useful behavior: default-on normalization that adds cost, full refund on server/provider failure, connection termination billed normally, and the output artifacts (MP3 + original ASS). This is well beyond what the annotations convey.

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

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

Purpose and cost behavior are front-loaded in the first sentences. The bracketed pricing formula is dense but arguably earns its place since it is billing-relevant and not captured elsewhere. Slightly heavy overall but no dead sentences.

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 14-parameter, zero-required, async creation tool with no output schema, the description usefully discloses the return artifacts and refund/billing rules. It stops short of explaining how the resulting job is tracked (e.g., via tts_jobs_status/tts_jobs_result) or whether a job id is returned, which would complete the picture.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value beyond the schema: normalize_text=false skips both execution and billing, and voice_id defaults to 'Kore' with a pointer to tts_gemini_voices for listing. The pricing formula also explains cost-driving 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?

States a specific verb+resource (submit Korean TTS job) and covers scope details like normalization and delivery format. However it never distinguishes this tool from the sibling creation tools tts_gemini_create and tts_openai_create, leaving the agent to infer which one to call for a given provider.

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 explains that normalize_text can be turned off and what happens on failure, but gives no explicit when-to-use guidance relative to the other TTS creation tools. With three near-identical create siblings, the absence of routing guidance is a real 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?

The description goes beyond the annotations by clearly stating that the server original is consumed on the first call and cannot be re-executed, matching destructiveHint=true. It also adds the context that there is no additional charge ([추가 과금 없음]), which is useful operational information an agent would need before invoking a destructive operation.

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

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

The description is compact and front-loaded, with the core action in the first sentence and the critical consumption warning immediately after. The bilingual repetition adds some redundancy but remains efficient and clear.

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

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

For a single-parameter, destructive download tool with no output schema, the description covers everything needed: what to download, the format, the completion precondition, the one-time consumption behavior, and cost implications. It is fully self-sufficient 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 100%: the job_id parameter already has a description ('completed 상태인 32자리 ID'). The tool description does not add new meaning to the parameter beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb ('Download'), a specific resource ('completed MP3 result'), and the exact output encoding ('as base64'). It clearly distinguishes this from sibling tools like tts_jobs_status (status check) or tts_jobs_subtitles (subtitle download) by specifying the result file itself.

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 clear usage context: the job must be 'completed' and the result can only be downloaded 'once'. It implies this tool is for the final retrieval step after creation and status checks, though it does not explicitly name alternative tools or state when not to use it.

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

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

Annotations already flag readOnlyHint=true. The description adds useful behavioral context beyond that: the operation is public, free, and reports specific lifecycle states plus MP3/ASS subtitle readiness. No contradiction is 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 short sentences front-load the main purpose and then add the exact state list and artifact readiness. The bilingual repetition is slightly redundant but still earns its place by adding specifics.

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 single-parameter status-checking tool, the description is sufficiently complete: it names all meaningful states and the readiness indicators. It does not explain response shape, but the status enumeration covers what an agent needs to interpret the result.

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 sole job_id parameter is already described as the 32-character ID received at submission. The description adds no further parameter detail, so the schema does the heavy lifting.

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

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

States a concrete action (get status/result availability) on a specific resource (TTS job) and enumerates the exact state values and artifact readiness flags. This clearly differentiates it from sibling tools like tts_jobs_create, tts_jobs_cancel, tts_jobs_result, and tts_jobs_subtitles.

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 makes the intended use clear: check a job's waiting/processing/completed/cancelled/failed state and whether MP3/ASS files are ready. It does not explicitly name alternatives or when-not-to-use, but the status/readiness focus is enough to route an agent correctly.

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 goes beyond the annotations by explaining that the subtitle source is consumed on call and cannot be re-executed, and that no additional charge applies. This is critical behavioral context for a destructive, non-idempotent operation.

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

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

The description is short, front-loaded with the core purpose, and each sentence adds value: output format, completion requirement, one-time consumption, and pricing reassurance. The bilingual repetition is justified for the target 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?

For a single-parameter tool, the description covers the essentials: what is returned, when it is valid, and what side effects occur. No output schema exists, but the base64 format is stated, so an agent has enough information to invoke 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 job_id parameter is already documented as a 32-character ID in completed state. The description adds no additional parameter-level meaning beyond that, matching the baseline for full 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 states a specific verb and resource: download completed ASS subtitles as base64. It clearly distinguishes this tool from siblings like tts_jobs_status and tts_jobs_result by specifying the subtitle deliverable and the one-time nature.

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 makes the intended context clear: the TTS job must be completed, and the download is a single-use operation. It does not explicitly name alternative tools or state when not to use it, but the completed-state condition is a clear usage signal.

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 cover the safety profile (readOnly=false, destructive=false, idempotent=false, openWorld=true), and the description adds genuinely useful non-annotation context: the default-on normalization cap, the per-job fee formula, and the fact that output structure (MP3/ASS) is unchanged when normalization is off. It does not explain whether the call returns a job handle or how to retrieve results, which is a notable omission for an async-looking job tool.

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

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

Three compact sentences, purpose front-loaded, no filler. The bracketed pricing formula is dense but is load-bearing information for a paid synthesis call rather than 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?

With no output schema, the description usefully states the output artifact structure, but for a 14-parameter tool with nested objects (speakers, utterances) and multi_speaker routing it omits how multi-speaker mode is invoked and how/whether results are polled via the tts_jobs_* siblings.

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

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

Schema description coverage is 100% across 14 parameters, so the schema already carries the semantics; the description only echoes the main input concepts (voice, style, text/utterances) without adding format or interaction detail beyond the schema. 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 states a concrete action — submit voice/style/body text to ChatGPT gpt-audio-mini for synthesis — naming both the engine and the inputs. It implicitly separates this from tts_gemini_create by naming the model, but it never explicitly contrasts the two sibling engines.

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: the 2,000-character normalization limit and the fee structure hint at when normalization matters, but there is no explicit when-to-use-this-vs-tts_gemini_create guidance or stated prerequisites.

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=false, so the safe-read nature is covered. The description adds one useful non-annotation detail, the [무료] (free) cost tag, but says nothing about the return format or count of voices.

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 plus a cost tag, with zero padding. Appropriately sized for a simple enumeration tool.

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

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

For a zero-parameter read tool with no output schema, the description gives enough to understand what comes back (voices and their tone characteristics) and that it is free. Minor gap is the absence of any note on return structure.

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. Baseline 4 applies as there are no parameter semantics to document.

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 (조회합니다/list) and resource (voices available in ChatGPT TTS plus their tone characteristics). This clearly differs from tts_gemini_voices by naming the ChatGPT provider, though it does not explicitly reference siblings.

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

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

No when-to-use guidance and no alternatives named. It does not say whether to call this before tts_openai_create to pick a voice, nor how it relates to tts_gemini_voices. Usage is only inferable from the tool's obvious role.

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 declare readOnlyHint=true and openWorldHint=false, so the safety profile is clear. The description adds a caveat that numeric input does not guarantee precise acoustic control, which is useful context beyond annotations, but it does not describe the return format or any other behavioral traits.

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

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

Three short sentences: purpose, a caveat, and a cost tag. The purpose is front-loaded, and every sentence adds value without 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 zero-parameter read-only lookup with no output schema, the description gives the gist but remains vague about what '표현 옵션' entails (e.g., specific style or emotion settings) and how the returned data is structured. An agent can infer it is a metadata lookup, but the description could be more explicit about the return content.

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 no parameters, so the baseline is 4. The description appropriately does not attempt to document any parameters, and the empty schema is consistent.

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 '조회합니다' (retrieve) and the resources (expression options and speaker count limits) for Gemini and ChatGPT. It distinguishes itself from siblings like tts_gemini_voices and tts_openai_voices, which list voices rather than options/limits, though the term '표현 옵션' remains somewhat abstract.

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

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

No explicit when-to-use or alternatives are given. The description never mentions that this is a preparatory step before tts_gemini_create or tts_openai_create, nor does it state any prerequisites. Only a caveat about numeric input is provided, which is behavioral, not usage 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=false, so safety is covered. The description adds real behavioral context: the result is an estimate plus a maximum reservation deposit, actual charges differ and must be read from completed-job billing, and the call is free ([무료]). These are meaningful traits not present in 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 short sentences with zero filler; the purpose is front-loaded, followed by the estimate-vs-actual caveat and the free-cost marker. Every sentence 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 read-only pricing tool with no output schema and fully documented parameters, the description covers purpose, cost model, and the estimate/settlement distinction. The only gap is that it does not say the quote is computed from the same synthesis payload used by the create tools, which matters given the nested speakers/utterances inputs.

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% with 14 well-documented parameters, so the schema carries parameter semantics and the baseline is 3. The description adds nothing about which parameters drive the quote (text length, engine, speakers), but is not expected to given full 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?

States a specific verb and resource: query the estimated cost of synthesis/normalization plus the maximum reservation deposit. It also distinguishes itself from the actual-billing path by telling the agent that real settlement is found in completed jobs' billing. It does not name the sibling tool that provides billing, 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?

Usage is implied rather than stated: the tool is for getting a cost estimate, and the alternative (completed-job billing) is mentioned for actual amounts. It never says explicitly to call this before tts_jobs_create or how it relates to tts_options, leaving the when-to-use 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?

The description adds behavior beyond the readOnlyHint annotation by stating that the tool downloads the media from a URL, produces a modulated copy, and returns the resulting file. It also discloses the per-call cost of 10 points. With annotations already covering safety, this is useful but does not specify the exact output format or delivery mechanism.

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 compact and front-loaded with the core purpose, followed by format support, return behavior, and cost. The English and Korean sentences are redundant for token efficiency, but the bilingual repetition is justified for the target audience. No irrelevant details are included.

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 two-parameter synchronous tool with full schema coverage and readOnlyHint, the description covers selection and invocation basics, including supported formats and return behavior. However, with no output schema, it leaves the output contract vague by only saying 'returns a modulated file' without specifying whether the result is a URL, binary data, or some other representation.

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

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

Schema description coverage is 100%, so the schema already documents type (1: low, 2: high) and media_url (allowed formats, max size). The description only adds natural-language examples that overlap with the schema, such as MP3/WAV and MP4/MOV, without contributing new parameter semantics.

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

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

The description states a specific verb ('modulate') applied to a clear resource ('the voice in a video or audio file') with a concrete outcome ('lower or higher pitch'). This unambiguously separates it from media-related siblings like video_to_mp3, stt, and tts_jobs_create, even though no sibling is named.

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 clear context for when to use the tool: whenever a user needs pitch modulation on a video or audio file. It also lists supported formats (MP3, WAV, MP4, MOV), which helps an agent decide input suitability. It does not explicitly mention alternatives or exclusions, so it stops short of a perfect score.

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