APICK Convert

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

Annotations already indicate readOnlyHint=true and openWorldHint=false. The description goes beyond by disclosing support for data URI prefixes and mentioning a per-call cost of 2 points, which are not in annotations. This adds useful behavioral context without contradicting the read-only signal.

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

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

The description is concise, front-loaded with the core action, and includes both English and Korean equivalents. Each sentence adds value: purpose, input specifics, and cost. The bilingual repetition doubles length but is still efficient 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?

The tool is simple: one parameter, no output schema, and clear annotations. The description states the return type ('original image file'), accepted input format, and cost. No further details, such as error handling, are necessary for this low-complexity operation.

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 parameter description already explains the base64 string and allowed data URI prefix. The tool description repeats the same information without adding new semantic details, so the baseline of 3 applies.

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

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

The description clearly states the function: decode a base64-encoded image string back into an image file, using the verb 'decode' and resource 'base64-encoded image string'. It also specifies accepted input variants (data URI prefix). This uniquely identifies the tool among siblings like pdf_to_image or docx_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 implies usage: convert a base64 image string to an image file. It does not explicitly mention alternatives or exclusions, but the context is clear enough, and the supported prefix adds practical guidance. No competing sibling has a similar purpose, so ambiguity is low.

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 openWorldHint=false, so the safety profile is covered. The description adds that only DOCX files are allowed and mentions a cost per call, but does not disclose whether the output is a file URL, binary, or any failure behavior. This is adequate but not rich.

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

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

The description is short and front-loaded, but it repeats the same information in English and Korean ('Convert a DOCX (Word) file to a PDF file.' vs 'DOCX 파일을 PDF 파일로 변환해 반환합니다.'). The redundancy slightly hurts structure.

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

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

This is a simple one-parameter tool with complete schema and annotations. However, with no output schema, the description does not specify what the response will be (e.g., a download URL or base64 PDF). The cost information is useful, but the missing return contract leaves a small gap.

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

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

Schema description coverage is 100% (the only parameter docx_url is fully described with URL format, MIME type, and size limit). The description's 'only DOCX format allowed' repeats the schema's MIME type, adding no new meaning.

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 names the exact resource transformation ('DOCX (Word) file to a PDF file'). This clearly distinguishes it from sibling tools like pdf_to_docx (reverse direction) and html_to_pdf (different source format).

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

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

The description implies usage: when you have a DOCX and need a PDF. It does not explicitly state when to use this over alternatives, nor does it mention exclusions beyond the DOCX-only restriction. No sibling tool is referenced as an alternative.

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 useful context: it returns a PNG image, supports common image formats, and mentions a per-call cost. It does not describe side effects or error behavior, but the read-only hint plus output format disclosure is sufficient for this straightforward transformation tool.

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

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

The description is compact, front-loaded with the core purpose, and every sentence adds value. It includes just enough detail about output format, adjustability, supported formats, and cost without verbose filler.

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

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

For a simple image transformation tool with rich schema descriptions and a read-only annotation, the description covers the essential context: what it does, output format, supported inputs, adjustability, and cost. It does not discuss failure modes or exact output dimensions, but these are not necessary given the tool's simplicity and schema coverage.

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

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

All parameters have schema descriptions, including defaults and ranges, so the schema already provides strong coverage. The description only mentions that font size, color, transparency, and density are adjustable, which adds no new meaning beyond the schema. This matches the baseline score of 3.

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

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

The description clearly states the tool draws a visible text watermark across an image and returns a PNG image. This distinguishes it from siblings like draw_watermark_pdf, set_watermark, and get_watermark by explicitly focusing on image inputs and output.

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 context by mentioning supported image formats (PNG, JPEG, etc.) and adjustable properties, implying it is for image files. It does not explicitly name alternatives or state when not to use it, but the sibling context and format list make the intended use reasonably clear.

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. The description adds that the tool returns a new PDF, applies the watermark across every page, supports adjustable parameters, and notes a per-call cost of 10 points. This goes beyond the structured annotations and schema.

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

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

The description consists of two sentences, front-loaded with a clear English directive followed by a Korean translation. It includes a cost notice and is economical overall, though the bilingual repetition adds slight 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?

With 9 parameters and no output schema, the description conveys essential behavior: returns a PDF, covers all pages, and only accepts PDF format. Parameter details are fully documented in the schema, so no critical context is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description lists adjustable attributes (font size, color, opacity, angle, density, area) which exactly mirror the schema properties, providing no additional semantic information beyond what the parameter descriptions already offer.

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

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

The description clearly states the tool 'Draw a visible text watermark across every page of a PDF file' and continues with the Korean equivalent, specifying the return of a watermarked PDF. This specific verb+resource combination distinguishes it from sibling tools like draw_watermark_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 tool's purpose is clearly implied for adding text watermarks to PDFs, and it notes that only PDF files are allowed. However, it does not explicitly compare with alternatives such as draw_watermark_image or set_watermark, nor does it mention when not to use the tool.

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 known. The description adds useful behavioral context beyond that: it returns a mosaic-processed JPEG, supports common formats, and notes per-call cost. This is valuable even though it doesn't mention side effects or failure modes.

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 a concise English sentence followed by a Korean equivalent and a cost note. It is reasonably compact and to the point, though the Korean section partially duplicates the English and schema information. Overall it is structured acceptably.

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 one required and one optional parameter, no output schema, and good annotations, the description provides a clear purpose, return format, supported formats, and cost. It does not cover error cases or threshold tuning beyond the schema, but the available information is sufficient for correct selection and basic invocation.

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

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

Schema description coverage is 100%, and both parameters (image_url and threshold) are well-described in the schema itself. The description does not add further semantic detail about parameters; it only repeats format support already covered by the schema. Baseline of 3 is appropriate.

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

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

The description uses a specific verb phrase 'Detect faces in an image and blur (mosaic) them' and specifies the resource (image) and the output (processed JPEG). This clearly distinguishes face_blur from sibling tools like draw_watermark_image or pdf_to_image, which have different purposes.

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 implied usage is clear: use this when you need to anonymize faces in an image. However, the description does not explicitly state when to use it versus alternatives, nor does it mention exclusions or complementary tools. It merely states supported formats and cost, so guidance is present but 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?

The description adds several behavioral traits beyond the readOnlyHint annotation: it returns JSON, is robust to image modifications, supports common image formats such as PNG/JPEG, and costs 10 points per call. This provides useful operational context without contradicting 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 description is concise and front-loaded with the core purpose. It contains a minor redundancy with the English and Korean sentences repeating the same general idea, but the Korean adds specific details about JSON return and cost. Overall, each sentence contributes useful information.

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

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

For a simple one-parameter tool with a readOnly annotation and no output schema, the description covers the essential aspects: what it does, return format (JSON), robustness, supported formats, and cost. It does not mention error handling for images without a watermark, but this is not critical for basic usage.

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 fully describes the only parameter (image_url) with details on allowed formats and maximum size (100% coverage). The description does not add additional meaning about the parameter beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Read the invisible watermark code embedded in an image' with a specific verb and resource. It also explains that the watermark code is returned as JSON, distinguishing it from sibling tools like set_watermark or draw_watermark_image that write or draw watermarks.

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 on when to use the tool (to read a watermark) and even notes it works even with partially modified images, implying suitability for distorted inputs. It does not explicitly name alternatives like set_watermark, but the purpose is self-evident and supported formats are listed, providing adequate 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?

The description adds valuable context beyond annotations: it mentions the cost ('30 points per call') and explicitly states the input (HTML string) and output (PDF file). Annotations already declare readOnlyHint, so the description adds further detail about the operation's behavior without conflicting.

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 brief and front-loaded with the core action. It avoids redundancy except for the intentional bilingual repetition, and includes the cost in a compact manner.

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 tool, the description plus schema and annotations cover the essential information: input, output, cost, and side-effect hints. It does not detail the return format (e.g., base64 vs. file path), but this is a minor gap given the tool's simplicity.

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 provides 100% coverage for both parameters with clear descriptions. The description only reiterates the html input ('HTML 문자열') and does not add meaning for the pagination parameter, so it stays at 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?

The description clearly states the tool's function with a specific verb and resource: 'Render HTML code into a PDF file.' This distinguishes it from siblings like pdf_merge and pdf_to_image, and the bilingual text reinforces the exact 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 is implied by the clear name and description, but there is no explicit guidance on when to use this tool versus alternatives, nor any mention of exclusions or prerequisites. It simply states what it does without context.

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

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

Annotations provide readOnlyHint=true, and the description adds that the tool 'converts and returns' a file, confirming no mutation. It also discloses a behavioral cost ('1 point per call'), which is not in the annotations. No contradiction exists. It doesn't detail edge cases but covers the key context beyond annotations.

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

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

The description is short and front-loaded with the English purpose, followed by Korean details. It includes a useful cost note and input format examples. The bilingual repetition is slightly redundant, but it's compact and each sentence adds some value, so a 4 is appropriate.

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 2-parameter conversion tool, the description covers the main points: input formats, return type (Excel file), and cost. No output schema exists, but the description does explain the output. It could mention optional sheet_name behavior or error handling, but these are minor gaps given the tool's simplicity.

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 a baseline of 3 applies. The description adds a JSON example and reiterates the supported data_list formats, but it omits the constraint that 2D arrays must have equal column counts, which the schema includes. Thus, the description does not significantly enhance the parameter meaning beyond the schema.

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

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

The description clearly states the tool's function: converting JSON data into an Excel (XLSX) file. This specific verb+resource combination ('Convert JSON data...') distinguishes it from sibling conversion tools like pdf_to_docx or html_to_pdf, which target different formats. The bilingual phrasing reinforces the core 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?

The description implies the use case: when JSON data needs to be converted to an Excel file. It provides specific input format constraints (object array or 2D array), which helps the agent decide if the tool is appropriate. However, it does not explicitly mention alternatives or exclusion conditions, so it's not fully aligned with a 5.

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

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

Annotations already declare readOnlyHint=true; the description adds extra constraints: only PDF files are allowed, order is preserved, and a per-call cost of 2 points applies. These go beyond the annotations and provide useful operational behavior, with no contradiction.

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 very concise, with an English lead sentence followed by a Korean equivalent that adds nuance (ordering, return behavior). It includes the cost note without fluff, making every word meaningful.

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 merge tool with no output schema, the description covers key aspects: merging behavior, order, and format restriction. It does not describe the return format (e.g., URL) or error handling, but given the simplicity and 100% schema coverage, it 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% with each parameter documented as a downloadable https URL with format and size limits. The description adds the important semantic that files are merged in the order of pdf_url_1 then pdf_url_2, which the schema alone does not convey.

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 'Merge' and clearly states the resource (two PDF files) and the outcome (one PDF). It is easily distinguished from sibling tools like pdf_to_docx or set_watermark, which serve different purposes.

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 it merges two PDFs in order and only accepts PDF format. It does not explicitly name alternatives or exclusion scenarios, but the sibling tool list makes the use case clear. The cost note adds practical context.

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

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

Annotations already provide readOnlyHint: true, so the read-only nature is covered. The description adds the format restriction and a cost note ('호출당 30포인트'), but it does not disclose the return mechanism (e.g., download URL vs. binary) or error handling, which would be useful given no output schema.

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

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

The description is short but contains redundancy: the English sentence 'Convert a PDF file to a DOCX (Word) file.' is essentially repeated in Korean ('PDF 파일을 DOCX 파일로 변환해 반환합니다.'). The additional format restriction and cost note are useful, but the duplication wastes space.

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 single-parameter conversion tool, the description gives the essential purpose and basic constraints. However, without an output schema, it does not specify how the converted DOCX is returned (binary, URL, etc.) or any failure contingencies, leaving a notable gap for an agent invoking the 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?

The input schema fully describes the sole parameter pdf_url with details on URL format, allowed MIME type, and size limit (100% coverage). The description merely repeats the PDF-only restriction and adds no new parameter-level information, so it meets the baseline for well-documented schemas.

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

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

The description clearly states 'Convert a PDF file to a DOCX (Word) file.' This specifies the verb, resource, and output format, distinguishing it from sibling tools like docx_to_pdf (reverse direction) 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 tool's name and description unambiguously identify it as the PDF-to-DOCX conversion tool. The explicit restriction 'PDF 형식의 파일만 허용됩니다' (only PDF format allowed) and the cost hint help set expectations, though no alternative tools or when-not-to-use scenarios are mentioned.

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 set readOnlyHint=true and openWorldHint=false, and the description adds valuable details: the output is a ZIP archive, each page becomes a PNG, and there's a per-call cost of 2 points. It doesn't contradict annotations and provides useful operational context beyond the 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?

The content is short but includes both English and Korean versions of the same sentence, which is redundant. The cost note is useful, but the duplication wastes space and doesn't help an AI agent.

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 converter, the description covers input, output, and a key restriction. It doesn't mention error handling, page count limits, or potential timeouts, but the simplicity of the tool and the schema's parameter detail make this adequate.

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 description covers 100% of the single parameter (pdf_url) with format, allowed type, and size limit. The description adds no new parameter-level details beyond reinforcing the PDF-only restriction, so it doesn't exceed the baseline for 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?

The description clearly states the tool converts each page of a PDF into PNG images and returns them as a ZIP archive. It uses a specific verb ('Convert'), identifies the resource (PDF pages), and specifies the output format, distinguishing it from sibling conversion 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 description gives clear context: it's for converting PDF pages to PNG images and notes that only PDF files are allowed. It doesn't explicitly mention when not to use it or point to alternatives, but the purpose is unambiguous enough for an agent to select it appropriately.

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 adds useful behavior: it returns a new PNG image, mentions robustness to partial image modification, and supports common formats. It also notes a cost per call. 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 concise and front-loaded with the core action. Although it mixes English and Korean, each sentence adds unique information: action, output format, robustness, supported formats, and cost. Minor redundancy but acceptable.

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 only two parameters fully described in the schema and no output schema, the description provides essential return format (PNG), robustness, supported formats, and cost. This is sufficient for a tool of this simplicity.

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 descriptive details for both parameters (code and image_url). The description does not add parameter-specific meaning beyond the schema, 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 clearly states the tool embeds an invisible watermark code into an image and returns a PNG image. This specific verb+resource combination distinguishes it from siblings like get_watermark (extraction) and draw_watermark_image (likely visible watermark).

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 establishes a clear use case: embedding invisible watermarks into images. It provides context about supported formats and output type, which implies when to use the tool, but it does not explicitly mention alternatives or exclusions.

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

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

Annotations declare readOnlyHint=true, and the description adds useful behavioral details: supported audio formats (MP3, WAV, etc.), return format (JSON), and a 50-point cost per call. This goes beyond the basic read-only safety hint.

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, but includes the same information in both English and Korean, creating slight redundancy. It remains efficient overall.

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

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

Given the simple nature of the tool and no output schema, the description mentions the return type (JSON) but not the exact structure or fields. It covers supported formats and cost, making it fairly complete but missing response shape details.

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

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

Schema description coverage is 100%, with detailed descriptions for both audio_url and language. The tool description adds no new parameter semantics beyond what the schema already provides, so baseline 3 applies.

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

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

The description clearly states the tool converts speech audio to text, using a specific verb ('Convert') and resource ('speech audio file'). This distinguishes it from siblings like tts (text-to-speech) and voice_change.

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 provides clear context: use when you need to transcribe audio files. However, it does not explicitly mention when not to use it or compare with alternatives such as tts, so no exclusions are given.

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

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

Annotations already declare readOnlyHint=true. The description adds non-obvious behavioral context: the per-call cost of 30 points, the 1,000-character limit, and the MP3 return format. No contradiction with annotations 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 two short sentences (one English, one Korean) plus a cost tag. It is front-loaded with the core action, efficient, and contains no filler or redundant detail beyond the bilingual restatement.

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 TTS tool with only 2 parameters and no output schema, the description adequately states the output format (MP3), input constraints, and cost. It lacks explicit failure/edge-case details but is complete enough for its 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 input schema already has 100% description coverage for both parameters, including the max length for 'content' and default for 'language.' The tool description repeats the 1,000-character limit but adds no new parameter-level meaning beyond the schema.

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

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

The description states a specific verb and resource: 'Convert text to a speech audio file (TTS, MP3).' It clearly identifies the tool's primary purpose and differentiates it from siblings like stt by function, though it does not explicitly name alternative 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 description provides clear usage context: Korean/English input, max 1,000 characters, MP3 output, and a 30-point cost per call. However, it does not explicitly state when to prefer this tool over alternatives or when not to use it, so it lacks explicit exclusions.

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

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

The description adds the cost per call ('[호출당 10포인트]') and confirms the tool returns a modulated file, complementing the readOnlyHint annotation. This provides useful behavioral context beyond the annotation, which already signals safety.

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 bilingual, adding length but remaining efficient. Every sentence provides value: pitch modulation, supported formats, return value, and cost. No unnecessary 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 clarifies that a modulated file is returned and lists supported input formats. For a simple two-parameter tool, this is adequate, though it does not specify the output format precisely.

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

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

The input schema already describes both parameters (type and media_url) with 100% coverage. The description mentions audio/video formats but does not add new semantic detail beyond the schema, such as the meaning of type values 1 and 2.

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

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

The description clearly states the tool modulates voice pitch in audio/video files, specifying 'lower or higher pitch'. This defines the function precisely and distinguishes it from sibling tools like stt/tts, which handle speech recognition and synthesis.

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 context of the tool's function and supported formats, implying when to use it. It does not mention explicit exclusions or alternatives, but given the distinct sibling set, such guidance is not essential.

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