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

With no annotations present, the description carries the full behavioral disclosure burden. It identifies the mutation ('Add a column') and the insert position behavior, but it does not disclose side effects, irreversibility, constraints, or what happens if the table index is invalid.

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 optimally sized: a one-line purpose statement followed by a compact Args list. There is no filler, and the parameter documentation is 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?

The description is adequate for a simple operation, and the output schema covers return values, so the lack of return documentation is acceptable. However, it omits edge-case behavior and mutability warnings, which matter for a table-modifying tool with no annotations.

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?

Although the JSON schema properties lack descriptions, the natural-language Args block documents all three parameters with useful meaning: doc_id as 'from open_document', table_index as the table's index, and col_index as the insertion position with the append-at-end default. This fully compensates for the 0% schema description 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 opens with 'Add a column to a table,' a specific verb-resource pair that unambiguously states the operation. It also differentiates itself from the sibling add_table_row and delete_table_column by clarifying it inserts a column, not a row.

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

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

The description provides no guidance on when to use this tool versus alternatives like add_table_row or split_table_cell. It does not state prerequisites, exclusions, or conditions under which adding a column would be preferred.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It discloses that the operation adds/inserts a row, that position defaults to end, and that a confirmation is returned. However, it does not mention side effects on existing rows, index base, or invalid position/table_index behavior.

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

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

The description is compact and well-structured: a one-sentence purpose, then Args and Returns sections. Every line contributes useful information and the format is 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?

The essential invocation details are present, and the output schema covers return value expectations. Still, without annotations, an agent lacks clear information about side effects of inserting rows, positional edge cases, or whether table indexes are zero-based.

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 0%, so the description must compensate. It provides meaningful one-line explanations for all three parameters, especially clarifying that position defaults to 'end'. It leaves some ambiguity around zero-based indexing and bounds, but it adds substantial meaning beyond the raw 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: 'Add a new row to a table.' This clearly distinguishes it from sibling tools like add_table_column, delete_table_row, and create_table.

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 purpose is clear enough to indicate when to use it, and the args provide useful context such as 'doc_id from open_document' and position defaulting to end. It does not explicitly discuss exclusions or alternatives, but no closely competing tool exists for the same operation.

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

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

No annotations are provided, so the description bears the full burden. It discloses a mutating append operation and a confirmation return value, but does not mention permissions, reversibility, formatting effects, or whether the document needs to be saved afterward.

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: one clear action sentence, then neatly labeled Args and Returns sections. There is no filler or redundant explanation; each line serves a purpose.

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 append tool with an output schema present, the description covers the action, parameters, and return confirmation. The main gap is the absence of behavioral caveats like document-save requirements or error conditions, but no annotations exist to fill that gap.

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

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

Schema coverage is 0%, and the description adds some meaning: doc_id is identified as coming from open_document, and text is described as paragraph text. However, 'Paragraph text' is largely tautological, and no format, length, or newline behavior is specified.

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 action ('Append a new paragraph'), the target resource ('the document'), and the exact location ('to the end'). This clearly differentiates it from sibling tools like insert_text or set_table_cell_text, which operate in other contexts.

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 usage context: appending a paragraph to the end of an open document, with doc_id sourced from open_document. It does not explicitly name alternatives or state when not to use it, but the prerequisite is evident.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It states 'Apply' implying a mutation, but does not disclose whether the operation modifies the existing table in place, overwrites content, or what side effects apply_target/create_mode produce. The brief arg list adds little behavioral context.

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 well-structured: a single front-loaded purpose sentence followed by a five-line args list. No filler or redundancy, though the args list is minimal and arguably repeats schema parameter names.

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 five parameters and zero annotation coverage, the description is too thin. It leaves unclear what template formats are accepted, what apply_target bitmask values mean, what create_mode options exist, and what state the table must be in. Even with an output schema, an agent lacks enough information to invoke this tool confidently.

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 0%, so the description must compensate. The Args section provides one-line glosses for all five parameters. Some add useful meaning ('Document ID from open_document', 'Template file path', 'Bitmask of what to apply'), while others are near-tautological ('Template format', 'Creation mode'). Partial compensation only.

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 'Apply a template to the current table' — a specific verb and resource. It is distinct from siblings because no other sibling tool mentions templates or applying them to tables. It doesn't elaborate on what the template does, but the core action is unmistakable.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisite conditions, and no mention of exclusions. The only contextual hint is 'current table' and doc_id being 'from open_document', but these are not framed 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?

There are no annotations, so the description alone must disclose side effects and behavioral details. It only says files are converted; it does not state whether the operation creates new files, overwrites existing ones, modifies the open document, or has other side effects. It also does not explain the relationship between doc_id and src_files.

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 well-structured: a one-sentence summary followed by a short argument list. Every piece adds some value, though the format could be slightly richer without becoming verbose.

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

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

The description is not complete enough for an agent to use the tool confidently. It does not explain when to choose this tool over single-format converters, how src_files and dest_files correspond, what happens with a null src_files or dest_files, or what the output looks like. The presence of an output schema reduces the burden for return values, but the operational gaps remain significant.

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 has 0% description coverage, but the description compensates by giving each parameter a meaningful one-liner: doc_id is tied to open_document, src_files and dest_files are path lists, and format is a target format string. It does not explain null/optional behavior or the pairing between source and destination files, so it is helpful but not exhaustive.

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 ('Batch convert files between formats') and names the involved formats (HWP, HWPX, PDF, DOCX). It is broad enough to cover multiple formats but does not explicitly distinguish itself from sibling tools like convert_to_pdf or convert_to_hwpx, so it falls just 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?

No guidance is given about when to use this tool versus alternatives such as convert_to_pdf or convert_to_hwpx. The word 'Batch' implies a multi-file scenario, but the description does not state this or any 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?

With no annotations, the description carries full burden. It only states the effect ('fill') without disclosing behaviors such as overwriting behavior, prerequisites (beyond doc_id origin), error handling, or partial failure semantics. This is inadequate for a mutation 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 extremely concise, leading with the core purpose ('Fill multiple fields at once') and then enumerating the two parameters in a clean Args block. No wasted words.

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

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

Given the tool has an output schema (not displayed) and only two parameters, the description provides basic completeness. However, it lacks behavioral context like whether the operation is atomic, whether it overwrites existing field values, or what happens if a field name is invalid. For a batch operation with no annotations, more detail is expected.

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 0%, but the description adds meaning: doc_id is identified as coming from open_document, and fields is described as a dict mapping field names to text values. This explains both parameters effectively, though it omits constraints like whether fields must pre-exist.

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 fills multiple fields at once, which is a specific verb+resource. The batch aspect distinguishes it from siblings like put_field_text (single field), making its purpose unambiguous.

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

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

The description implies use for batch operations but does not explicitly mention alternatives or when not to use it. It lacks explicit guidance like 'use for multiple fields; use put_field_text for single fields,' so usage context is only implied.

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

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

Without annotations, the description carries the full burden of behavioral disclosure. It only says 'check if exists', which implies read-only behavior, but it does not explicitly state side effects, return behavior, error handling for missing objects, or whether the document is modified.

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 purpose, followed by a minimal Args list. Every line adds necessary information; there is no filler, though the prose could have spent one more sentence on return semantics.

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 existence check with an output schema, the core invocation information is present. However, the undefined 'X object' and the complete absence of usage guidance or alternatives leave a noticeable gap for an agent unfamiliar with the domain.

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 has 0% description coverage, so the Args section is the only source of parameter meaning. It usefully explains that doc_id comes from open_document and name is the object name to check, adding real value beyond the bare parameter titles.

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 verb-resource pair: checking whether an X object exists by name within a document. It is clearer than the bare tool name because it adds the existence-check semantics and the lookup key (name), though it does not define what an 'X object' is or differentiate itself from sibling existence/search 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?

There is no guidance about when to use this tool versus alternatives like field_exists or find_ctrl. No conditions, exclusions, or preconditions are given beyond the required arguments, leaving the agent to infer appropriate invocation 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It says 'Clear the current text selection' but does not state whether selected content is preserved, whether the cursor moves, or what side effects occur. It also fails to mention that doc_id is needed to identify the target document.

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 no filler, which is appropriate. However, it is under-specified to the point of omitting the parameter and usage context, so brevity comes at the expense of usefulness.

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 tool is relatively simple, but with no annotations, a required doc_id param, and related sibling tools, the description leaves out essential context: which document the selection applies to, whether content is preserved, and how this differs from delete_selection. It is not complete enough for an agent to confidently invoke it correctly.

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

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

Schema description coverage is 0%, and the description does not mention the required doc_id parameter at all. The only parameter remains entirely undocumented by both the schema and description, so the agent has no semantic guidance beyond the minimal 'Doc Id' title.

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

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

The description states a clear verb and object: 'Clear the current text selection.' The purpose is unambiguous, but it does not differentiate itself from sibling tools like delete_selection, which could plausibly mean removing the selected content, or select_text. The absence of an explicit 'without deleting content' qualifier leaves a small 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?

There is no guidance about when to use this tool versus alternatives such as select_text, get_selection_info, or delete_selection. The description only states what it does, not when or why an agent should prefer it over related selection tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says it closes an open document and returns 'Confirmation with status.' It does not disclose whether unsaved changes are discarded, whether a prompt may appear, what happens with an invalid doc_id, or any side effects of closing.

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, front-loads the core action, and includes only necessary sections for arguments and return value. Every sentence contributes useful information with no redundancy or 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 one-parameter tool with an output schema, the description covers the essential invocation details: the action, the argument source, and a basic return description. However, the lack of annotations and the absence of any mention of save/discard behavior leave some risk for an agent invoking this state-changing operation without knowing its full impact.

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 only the name and type of doc_id, so the description adds meaningful context by specifying that it is 'Document ID from open_document.' This tells an agent exactly where to obtain the value, which is sufficient guidance for the single parameter.

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

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

The description states a specific verb and resource: 'Close an open document.' It clearly distinguishes this tool from siblings like open_document and save_document by focusing on the closing action and the precondition that the document is already open.

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 primary usage context: the document must already be open, and the doc_id should come from open_document. However, it does not explicitly state when to prefer this over alternatives like save_document, nor does it mention any exclusions or prerequisites beyond having opened the document.

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?

There are no annotations, so the description carries the burden of behavioral disclosure. It mentions the output path and that a conversion confirmation is returned, but it does not disclose whether the original document is modified, whether an existing output file is overwritten, or whether the source document remains open.

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 a clear one-line purpose followed by concise Args and Returns sections. Every sentence earns its place and there is 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?

For a two-parameter conversion tool, the description covers the inputs, the output path, and the return value. It is largely complete, though it would be slightly stronger if it addressed overwrite behavior or side effects on the source document.

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 0%, so the description must compensate for the two parameters. It does this reasonably well by explaining that doc_id comes from open_document and that output_path is the destination for the HWPX file, adding meaning beyond the bare string schema titles.

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: convert an HWP document to HWPX format. This clearly distinguishes it from conversion-oriented siblings like convert_to_pdf, and it is not a tautology of the tool name.

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

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

The docstring gives a useful prerequisite by stating doc_id should come from open_document, which helps an agent know what input to supply. However, it does not explicitly explain when to prefer HWPX over alternatives such as save_document_as or convert_to_pdf, nor does it name any 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states the action and return value ('Returns: Conversion confirmation with path'), but it does not mention side effects, whether existing files are overwritten, whether the document is modified, or whether permission or file-system constraints apply.

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 well-structured, with a front-loaded purpose statement followed by clearly labeled Args and Returns sections. Every line earns its place and there is no redundant or filler content.

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 is nearly complete: it explains both arguments, references open_document for the source ID, and states the return value. Minor omissions include whether the output path must end in .pdf and whether an existing file at that path is overwritten, but these do not seriously impair call correctness.

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 property descriptions are absent, so the description must compensate. It does so fully by explaining both parameters: doc_id is 'Document ID from open_document' and output_path is 'Output file path for the PDF.' This adds meaningful context well beyond the bare 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: 'Export document as PDF.' This is unambiguous and clearly describes the tool's operation. However, it does not explicitly differentiate this tool from sibling alternatives like export_page_as_image or save_as_image, so it falls 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?

The description gives implied usage guidance by noting 'doc_id: Document ID from open_document,' which tells the agent that a previously opened document is required. However, it does not explicitly state when to use this tool versus alternatives such as export_page_as_image or batch_convert_files, nor does it provide any exclusion criteria.

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

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

No annotations are provided, so the description carries the full burden. It says 'Convert' but does not disclose whether this is a pure read-only conversion, whether it mutates the document, or why doc_id is required. For a conversion tool, side effects and context dependence should be clarified.

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 and front-loaded, with no filler or redundant sentences. The unit names add substance, though the brevity comes at the cost of missing parameter and behavioral context.

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

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

An output schema exists, so return-value details are not required from the description. However, the mandatory doc_id parameter has no explained purpose, and the lack of parameter descriptions leaves the tool incomplete for confident 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 0%, so the description must compensate. It does add meaning to from_unit and to_unit by listing possible unit values, but it leaves value and especially doc_id unexplained, and it does not specify the exact accepted string formats or conversion behavior.

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

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

The description states a clear verb ('Convert') and resource ('units') and explicitly names the supported unit families (mm, pt, hwpunit), so an agent can understand the core purpose. It does not explicitly contrast with sibling tools, but no sibling appears to offer the same conversion capability.

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 by the tool name and the unit list, but the description gives no explicit when-to-use or when-not-to-use guidance. There are no alternative conversion tools among the siblings, so the lack of explicit routing is less damaging, but still not addressed.

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

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

With no annotations, the description alone carries the behavioral disclosure burden, but it only repeats the core action. It does not state insertion behavior, whether the equation replaces a selection, dialog behavior, error conditions, or effects on the document.

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

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

The description is a single front-loaded sentence with no filler. It is concise, though the brevity sacrifices substance needed for a non-trivial tool.

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

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

The description is not complete enough to invoke the tool correctly: it omits how the equation string should be formatted, where the equation is placed, and what the font parameters control. An output schema exists but is not shown, and no annotations fill these gaps.

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

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

Schema description coverage is 0%, so the description must compensate, but it does not explain any of the four parameters. It only mentions HWP equation syntax generally, leaving doc_id, equation format, font_name, and font_size semantically undefined.

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 action ('Create an equation') and the domain ('HWP equation syntax'), which distinguishes it from text or picture insertion siblings. It does not explicitly contrast with any sibling tool, but the verb and resource are clear enough for basic selection.

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

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

There is no guidance about when to use this tool versus alternatives like insert_text, insert_picture, or create_table. No prerequisites, expected document state, or exclusions 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?

No annotations are provided, so the description carries the full behavioral burden. It only states the action and parameter meanings; it does not disclose return behavior, failure modes (e.g., duplicate field names), or side effects such as where the field is inserted.

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 clear purpose sentence followed by a compact Args block. Every line earns its place, and the most important information is front-loaded.

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

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

The description covers purpose and parameter semantics well, and an output schema exists so return-value documentation is not necessarily required. However, the lack of usage guidance versus sibling field tools and the absence of side-effect disclosure keep it from being fully complete, especially with no annotations.

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 0%, but the description compensates by explaining all four parameters. The direction 0/1 mapping and doc_id provenance from open_document are genuinely useful; name and memo are minimal but still map correctly to schema properties.

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 action ('Create') and resource ('named field'), with the parenthetical 'placeholder for templates' clarifying the kind of field. This distinguishes it from sibling field tools like get_field_text, rename_field, and put_field_text, which operate on existing fields rather than creating placeholders.

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 use when a new template placeholder field is needed, and 'doc_id: Document ID from open_document' gives a useful prerequisite. However, it does not explicitly name alternatives or state when not to use this tool versus the many sibling field-manipulation 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It states the core effect (create a table) and the return behavior ('Table creation confirmation'), which is helpful. But it does not disclose where the table is inserted (e.g., cursor position), validation rules for rows/cols, or any side effects on the document.

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 purpose. The Args list is a lean, readable mapping of all four parameters with no redundant filler. The Returns line closes it efficiently. 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 4-parameter mutation tool with no annotations and no schema descriptions, the description covers parameters and return but omits behavioral context like insertion point, validation ranges, or what happens if data dimensions mismatch. An output schema exists, which may explain the return value, but it is not provided here, so the description alone is not fully complete.

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

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

Schema description coverage is 0%, but the description compensates well by explaining every parameter: doc_id is 'Document ID from open_document', rows/cols are counts, and data is an optional 2D array of initial cell values. This adds real meaning beyond the raw schema. Slightly more detail on data constraints (e.g., must match rows/cols) would push it to 5.

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

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

The description opens with a specific verb-resource pair: 'Create a new table in the document.' This is immediately distinct from siblings like add_table_row, merge_table_cells, and get_tables, which all operate on or inspect existing tables. The doc_id prerequisite from open_document further anchors the 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?

The description implies the use case: call this when you need a new table. However, it never explicitly names alternatives or states when not to use it, such as when converting existing text to a table via text_to_table. The doc_id hint implies a prerequisite but does not provide 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?

With no annotations provided, the description bears full responsibility for behavioral disclosure. It only states that it deletes a selected control object, but does not mention side effects, whether the action is undoable, what happens if no control is selected, or any permission requirements. For a destructive operation, this is insufficient.

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 short and front-loaded with the main purpose, which is good for conciseness. However, it is under-specified, omitting critical behavioral details. It is not overly verbose, but the brevity is more due to missing information than efficient structure, so it does not fully earn a higher score.

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

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

The tool is destructive and lacks annotations, yet the description does not cover prerequisites (e.g., must have a selection), error conditions, or result expectations. Although an output schema exists (not shown), the behavioral context is still incomplete. An agent would lack crucial information to call this tool safely and effectively.

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 has 0% description coverage, so the description must compensate. It does add value by explaining that doc_id is 'Document ID from open_document', providing source context. However, it does not clarify the meaning of 'control object' or selection mechanics, leaving some ambiguity. It barely meets the need for parameter explanation.

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

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

The description clearly states the action ('Delete') and the resource ('currently selected control object'), which is specific and unambiguous. However, it does not distinguish itself from sibling tools like 'delete_selection' or 'delete_table_row', so it lacks explicit differentiation for an agent choosing among them.

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

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

The description provides no guidance on when to use this tool over alternatives, nor any prerequisites or conditions for use. The only extra information is the doc_id parameter source, which is part of the schema, not usage context. An agent has to infer that 'currently selected' implies a prior selection step.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It identifies this as a destructive 'Delete' operation but does not mention side effects such as selection state, undo behavior, or whether the deletion is permanent. The option field is also left ambiguous beyond the value 0.

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 appropriately short and front-loaded with the main action. The Args section is useful and free of fluff. It loses one point because the option explanation is ambiguous enough that it could mislead rather than clarify.

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 destructive tool with no annotations, the description is too sparse. It does not address preconditions beyond doc_id origin, alternative option values, or post-condition behavior. The presence of an output schema reduces the need to explain return values, but the missing operational context still makes this incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for doc_id by linking it to open_document, and it explains option as '0 = selected content.' However, it does not clarify whether other option values exist or what they do, leaving an integer parameter partially unexplained.

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: 'Delete the selected content.' This makes the tool's core function clear. However, it does not explicitly differentiate from siblings like clear_selection or delete_ctrl, so it falls short of full clarity.

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

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

There is no guidance on when to use this tool versus alternatives. The only contextual hint is 'doc_id: Document ID from open_document,' which implies a prerequisite but does not explain when deletion is appropriate or when another tool should be used 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only states that a column is deleted. It does not mention irreversibility, side effects on table data, index validity, or any permissions/constraints, which is a significant gap for 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 purpose, followed by a clean parameter list. Every line earns its place, and there is no redundant or filler content.

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?

Although an output schema exists, the description still lacks important context for correct invocation, such as how to get valid table/column indices and what happens after deletion. The doc_id prerequisite is mentioned, but destructive behavior and preconditions are otherwise unexplained.

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 0%, so the description must compensate. It does describe all three parameters, and 'Document ID from open_document' adds provenance beyond the schema, but 'Index of the table' and 'Index of the column' mostly restate parameter names and do not specify zero-based indexing or how the indices should be obtained.

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: 'Delete a column from a table.' This clearly distinguishes it from sibling tools such as add_table_column and delete_table_row by naming the exact action and target.

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 or exclusions are provided. The description does not explain when to choose this over delete_table_row or how to obtain valid table/column indices, leaving the agent to infer usage from the tool name alone.

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

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

With no annotations, the description must disclose behavioral traits, but it only says 'Delete a row' and mentions a confirmation return. It does not warn about irreversibility, required preconditions, index base, or side effects.

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

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

The docstring is compact and well-organized with Args and Returns sections. The main action is front-loaded, and every line serves a purpose without 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?

For a simple three-parameter delete operation, the description provides a workable minimum: it names the action, defines all inputs, and states the return. However, it omits important invocation context such as indexing convention, irreversibility, and behavior when row or table does not exist.

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 0%, and the description compensates by explaining all three parameters. Notably, doc_id is tied to open_document, and both indexes are described. It could add precision by noting whether indexes are zero-based, but it still adds clear meaning beyond the raw 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?

Description states a precise operation ('Delete a row from a table') with a specific resource. The verb and object differentiate it from siblings like delete_table_column and add_table_row, but it does not explicitly name those alternatives, so it stops short of a 5.

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

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

There is no when-to-use guidance, no exclusions, and no mention of how this tool differs from other table manipulation tools. An agent gets parameter lists but no context for choosing this over siblings like delete_table_column or add_table_row.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says the page is exported as an image; it does not mention whether an existing output file is overwritten, whether the document must be open, how DPI affects the result, or any side effects of writing to output_path.

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

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

The description is a single focused sentence and the format list is front-loaded in parentheses. It is appropriately terse, though it could spend one more sentence on usage or output behavior without becoming bloated.

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

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

For a file-exporting tool with five parameters and no annotations, this description is incomplete. It omits output-path semantics, format/dpi constraints, and any conditions needed for a successful export, so an agent cannot fully plan the call from the description alone.

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

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

Schema description coverage is 0%, so the description should compensate by explaining the parameters, but it only lists image formats. It adds no meaning for doc_id, output_path, page_number, or dpi, leaving an agent to rely on parameter names alone.

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: 'Export a page as an image file,' and it lists the supported formats (bmp, jpg, png). It is clear enough to identify the action, but it does not differentiate from the sibling 'save_as_image', so the purpose is not fully disambiguated.

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 'save_as_image' or 'print_document'. There are no conditions, exclusions, or examples, so an agent must guess which export tool fits a given task.

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 are absent, so the description carries full responsibility for behavioral disclosure. It does not say whether exporting modifies the document, where the exported style goes, what format is produced, or what the return value represents. It only restates the action and parameter sources.

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: one clear purpose sentence followed by a brief arg list. There is no fluff or redundancy. It could be slightly more informative while remaining short, but it is not padded.

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 is minimally serviceable, but it omits important context: whether the document is modified, what the export output is, and how this relates to import_style/manage_style. The presence of an output schema reduces the need to document return values, but the missing behavior and routing context still leave it incomplete.

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

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

Schema coverage is 0%, so the description must compensate. It adds some value by noting doc_id is a 'Document ID from open_document,' but the style parameter is just 'Style name to export,' which adds no meaning beyond the schema's type and title.

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: 'Export a style from the document.' This clearly distinguishes it from the sibling import_style, though it does not explicitly mention any sibling. The arg list reinforces the resource by naming doc_id and style.

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

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

There is no guidance on when to use this tool versus alternatives such as import_style or manage_style. The only implied prerequisite is that doc_id comes from open_document, but no when-to-use or when-not-to-use conditions are stated.

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

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

No annotations exist, so the description must disclose behavior. It is silent on return type (likely boolean), side effects (read-only or not), and error conditions. It only infers the need for an open document via the doc_id parameter description.

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 extremely concise, with a single-purpose statement and clear parameter lines. It is front-loaded with the action.

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 tool's simplicity, more is expected: the return value, whether the document must be open, and any type restrictions on fields are not mentioned. The presence of an output schema (not shown) partially compensates, but the description alone leaves ambiguity.

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 0%, so the description provides the only meaning. It explains doc_id as coming from open_document and name as the field name to check. This adds some context but is minimal and does not fully clarify expected formats or constraints.

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

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

The description states a clear purpose: checking existence of a named field in a document. It uses a specific verb and resource, distinguishing it from siblings like get_field_list or get_field_text, though it doesn't explicitly name alternatives.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., document must be open) or scenarios where this is preferred over listing fields or checking via other means.

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

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

With no annotations, the description carries the full behavioral disclosure burden, but it only says 'Find a control object' and does not explain search scope, side effects, failure behavior, or what happens when no control is found. This is not enough for an agent to predict the tool's behavior.

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

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

The structure is clean and front-loaded: a one-line purpose followed by the argument. It contains no filler, but it achieves brevity by omitting information needed for safe use, so it is under-specified rather than optimally concise.

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

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

Despite having an output schema and a single parameter, the description leaves key context undefined: what a control object is, which control object is found, and what prerequisite document state is required. An agent familiar with the domain may infer some of this, but the definition is not complete enough for reliable tool selection.

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 single parameter is minimally covered by the input schema, and the description adds that doc_id is the document ID from open_document. This clarifies the parameter's provenance, though it does not explain how to obtain or validate the ID beyond that.

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 operation—find a control object—and the document scope. However, it does not define what counts as a control object or distinguish itself from similar object-related siblings like delete_ctrl or get_tables.

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

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

The description gives no guidance on when to use find_ctrl versus alternatives, and no exclusions or selection conditions are stated. The only contextual hint is that doc_id comes from open_document, which is a precondition 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?

No annotations are provided, so the description bears the full burden of explaining behavior. The description implies a read-only lookup, but does not disclose whether the cursor must be inside a field, what happens if no field is at the cursor, or whether any state changes occur. The vague 'option: Detection option' also obscures behavior.

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

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

The description is short and front-loaded with the main purpose. The Args block is compact and readable, though it partly repeats the schema. It earns its place with the provenance hint for doc_id, but the option explanation adds no real value.

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 there are no annotations and one parameter is nearly undocumented, the description leaves too much to inference. The output schema may explain return values, but the description still lacks prerequisites, edge-case behavior, and any guidance on the option parameter. An agent would likely need to experiment to use this 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 0%, so the description must compensate. It adds minimal value: doc_id is identified as a document ID from open_document, which is helpful, but 'option' is only labeled 'Detection option' with no meaning or accepted values. The parameter semantics are therefore under-specified.

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 job: get the field name at the current cursor position. It uses a specific verb and resource, and is distinguishable from siblings like set_current_field_name or get_field_list. However, it does not explicitly differentiate itself from nearby field-related 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?

There is no guidance about when to use this tool versus alternatives such as move_to_field, get_field_list, or get_selection_info. The parameter list says doc_id comes from open_document, but gives no context about prerequisites, cursor state requirements, or when another tool would be more appropriate.

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

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

No annotations are provided, so the description carries the burden. 'Get' implies a read-only operation and the return tuple is disclosed, which is useful. But the description does not mention side effects, prerequisites such as whether the document must be open, or error behavior.

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

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

The description is a single efficient sentence with zero filler. It front-loads the core action and includes the exact return fields, making it easy to parse quickly.

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 getter with an output schema, the description conveys the essential purpose and return shape. However, it omits usage context such as prerequisites, relation to the doc_id parameter, and any distinguishing guidance against closely related sibling tools.

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 0% and the description adds no meaning for doc_id beyond what the input schema already provides. While the parameter name is self-explanatory, the description fails to clarify which document's cursor position is being read or any required state.

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 ('Get') and resource ('current cursor position') and names the returned components (list, para, pos), making the tool's function immediately obvious. It is clearly distinguished from sibling setters like set_cursor_position and move_cursor.

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 by the name and description: call when you need the current cursor position in a document. However, there is no explicit guidance about when to prefer this over related tools like get_pos_by_set or get_selected_pos_by_set, nor any exclusion criteria.

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

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

With no annotations, the description carries the behavioral burden, but 'Get document metadata' clearly signals a read-only information retrieval operation with no apparent side effects. It does not address error cases, prerequisites such as an open document, or permission requirements, but for a simple getter the core behavior is reasonably 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 a single concise sentence that front-loads the verb and resource, then lists examples of the metadata returned. Every word earns its place and there is no 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?

An output schema is present, so return-value documentation is handled externally. The description covers the basic purpose and sample metadata, but lacks guidance on when to choose this over similar sibling tools and does not mention behavioral constraints or prerequisites. For a simple getter this is adequate but not comprehensive.

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 only 'doc_id' with no description, and the tool description does not explain it beyond the context of fetching document metadata. However, the single parameter is self-explanatory in this context, and the description adds useful output-oriented context (page count, modification status, path, version).

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 ('Get') and names the resource ('document metadata') with concrete examples (page count, modification status, path, version). It is clearly a metadata retrieval tool, though it does not explicitly differentiate itself from similar getters like get_document_summary or get_file_info.

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

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

No guidance is provided about when to use this tool instead of siblings such as get_document_summary, get_page_count, or get_file_info. The description implies a generic metadata lookup but does not state conditions, exclusions, or preferred scenarios.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It reveals the tool can either read or mutate summary metadata, but it does not disclose whether setting values replaces or merges existing metadata, what happens when values is null, or whether an open document is required. Permissions, side effects, and error conditions are also absent.

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

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

The description is a single compact sentence that front-loads the key resource and includes illustrative fields. It is appropriately brief, though the packed 'get or set' phrase slightly obscures the tool's conditional behavior.

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?

Even though an output schema exists, the dual get/set behavior and the free-form values parameter require more explanation than the description provides. An agent cannot determine how to trigger a set operation, what valid keys look like, or what the null default means, leaving a significant gap for a state-changing tool with no annotations.

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 0% schema description coverage, the description must compensate, but it only partially does so by listing possible summary fields ('title, author, subject, keywords'). It fails to explain the meaning of doc_id, the expected shape of the values object, or how values controls get versus set behavior.

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 pair ('get or set') and a specific resource ('document summary info') with example fields, making the tool's core purpose clear. However, it does not distinguish itself from sibling tools such as get_document_info or set_hwp_property, and the combined 'get or set' phrasing leaves some ambiguity about when each behavior applies.

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 for when to use this tool versus alternatives like get_document_info or set_hwp_property. The description implies both reading and writing summary info but never explains how to choose between them or what conditions favor this tool. There are no exclusions, prerequisites, or alternative tool mentions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation and return value, but does not explicitly confirm read-only behavior, side-effect-freeness, or any constraints on the returned text (e.g., whether it includes table or field content). 'Get' implies non-mutating behavior, but that is an inference, not a disclosure.

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

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

The description is compact, well-organized with Args and Returns sections, and contains no filler. Each line earns its place, and the main purpose is front-loaded.

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

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

For a simple one-parameter read tool with an output schema, the description captures the essential purpose, argument provenance, and return value. However, it lacks any usage guidance, behavioral guarantees, or disambiguation from closely related text-retrieval siblings, so it is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics beyond the bare 'string' type by stating that doc_id is the 'Document ID from open_document,' which conveys provenance and a workflow dependency. It could specify format expectations, but for a single parameter this is a useful level of 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 clearly states the action: 'Get all text content from the document.' This gives a specific verb, resource, and scope, making the tool's core purpose immediately understandable. It does not explicitly contrast with sibling tools like get_page_text or get_paragraphs, so it stops short of full differentiation.

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

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

The description does not explain when to choose this tool over alternatives such as get_page_text, get_paragraphs, or search_text. It only mentions that doc_id comes from open_document, which is a precondition rather than usage guidance. No exclusions or alternative routing are provided.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. 'Get list' clearly implies a read-only operation, and it usefully specifies that doc_id comes from open_document. However, it does not explicitly state that the document is not modified, nor does it describe ordering or failure behavior, though the output schema may cover return structure.

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 a clear one-sentence purpose followed by a concise argument list. Every line adds useful information and there is 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?

For a simple list/getter tool, the parameter semantics are well covered and an output schema exists, so return-value details are unnecessary. The main missing piece is usage context relative to sibling field tools, but that is not essential for a correct invocation.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining all three parameters: doc_id is the document handle from open_document, option maps 0 to all fields and 1 to clickhere-only fields, and direction maps 0 to horizontal and 1 to vertical. This gives the agent everything needed to set parameters correctly.

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 verb 'Get' and the resource 'list of all fields in the document', making the tool's core purpose unambiguous. It does not explicitly contrast itself with sibling field-related tools like get_field_text or field_exists, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus alternatives such as field_exists, get_field_text, or get_current_field. The description only explains what the tool does and its parameters, leaving the agent to infer the appropriate context for calling 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only identifies the input parameters and the fact that text content is returned; it does not describe behavior for missing fields, non-text fields, or error conditions, nor clarify whether this is a safe read-only 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 extremely concise and front-loaded with the core purpose, followed by a compact Args section. Every sentence earns its place with no filler or 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 simple two-parameter getter, the description is largely complete for invocation, and the presence of an output schema means return-value documentation is not required. It lacks only richer usage context and behavioral caveats, which are already penalized in other dimensions.

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 0%, so the description must compensate for the bare schema. It does so by explaining doc_id as 'Document ID from open_document' and name as 'Field name', which gives an agent enough semantic context for both required 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 states a clear verb ('Get') and resource ('text content of a named field'), which accurately conveys what the tool does. It is distinct enough from siblings like get_field_list or put_field_text, though it does not explicitly name an alternative to differentiate from.

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 use this tool versus related field operations such as get_field_list, field_exists, or put_field_text. The description implies a read operation from context, but it does not state conditions, exclusions, or alternatives.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It meaningfully discloses that the document will not be opened, implying no editor state change. It does not mention permissions, side effects, or error behavior, but 'get metadata' is inherently read-oriented.

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

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

A single sentence with no filler. The action is front-loaded and the key behavioral constraint ('without opening the document') is immediately 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?

The output schema presumably covers return values, so the description only needs to convey purpose and usage. It does that clearly, though path-format guidance and explicit differentiation from document-info tools are left implicit. Minor gaps for a simple one-parameter read 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 schema has one parameter, file_path, with 0% description coverage. The description does not compensate by explaining path format, whether the file must already exist, or how the path is resolved. The parameter name is suggestive but the description adds no semantic 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?

States a specific verb+resource ('Get file metadata') and a distinguishing behavioral constraint ('without opening the document'), which clearly separates it from document-opening tools like open_document and get_document_info.

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

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

Provides clear context: use this when you need file-level metadata and do not want to open the document. It does not name sibling alternatives or give explicit when-not guidance, but the usage intent is unambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only operation, but the description does not state whether form control data includes values, properties, or layout, nor any side effects, permissions, or edge cases.

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

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

The description is a single, front-loaded sentence with no redundant wording. It communicates the core operation efficiently, though at the cost of missing richer guidance.

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 parameter, no annotations, and no parameter descriptions, the definition is too thin to fully guide correct invocation. The output schema may document return values, but the description still lacks parameter semantics, usage context, and behavioral 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 0%, and the description does not explain the doc_id parameter beyond its name. The agent can infer that doc_id identifies the target document, but no format, meaning, or relationship to the retrieved form data is provided.

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

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

The description names a specific verb and resource: 'Get form control data' from the document. It is clear enough to distinguish from most sibling tools, but it does not explicitly differentiate it from similar data-retrieval tools like get_field_text or get_table_data.

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 prefer this tool over alternatives or when not to use it. With over 100 sibling tools, including several other 'get' operations, the lack of routing guidance leaves the agent to infer 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?

There are no annotations, so the description must disclose behavioral traits itself. It indicates a read operation by the word 'Get,' but it does not mention side effects, error behavior for invalid property names, permissions, or whether the COM object must be initialized. This is a significant gap for a tool with no annotation support.

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 well-structured: a clear one-sentence purpose followed by an Args block. There is no filler or redundant restatement of the schema.

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

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

This is a simple one-parameter getter with an output schema available, so the description does not need to explain return values. However, without annotations, it lacks behavioral context and guidance on valid property names, leaving the tool only minimally complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning by labeling property_name as a property name and giving concrete examples ('Version', 'CurFieldName'). However, it does not enumerate valid property names, note case sensitivity, or explain the allowed domain beyond two examples.

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: 'Get a property value from HWP COM object.' It clearly conveys the tool's action and is not a tautology. It does not explicitly name a sibling for contrast, but 'get' inherently differentiates it from the sibling set_hwp_property.

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

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

No guidance is provided about when to use this tool versus alternatives like set_hwp_property, hwp_enum, or other property-related tools. The examples hint at usage context, but there are no exclusions, prerequisites, or selection criteria.

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

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

No annotations are provided, so the description carries the burden of behavior disclosure. 'Get current message box mode' implies a read-only retrieval with no side effects, but it does not elaborate on possible return values, failure cases, or whether the mode reflects global or document-specific state.

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

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

The description is a single, focused sentence with no filler. It front-loads the operation ('Get') and the target ('current message box mode') and earns its place completely.

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 zero parameters and an output schema present, the description is nearly sufficient for an agent to invoke the tool correctly. It would be slightly more complete with a note about what 'message box mode' represents, but nothing critical is missing for 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?

The tool has zero parameters, so there is no parameter meaning to clarify. The baseline of 4 applies, and the description correctly signals that no input is needed.

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 ('Get') and a clear resource ('current message box mode'), making the tool's function immediately understandable. It also naturally distinguishes itself from the sibling tool set_message_box_mode by focusing on reading rather than setting the mode.

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: call this when you need the current message box mode. However, the description does not explicitly state when to use it, what conditions favor it, or contrast it with set_message_box_mode or related state-reading tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a read-only 'Get' action but does not mention whether the document must be open, what happens for invalid doc_id values, or whether page count is computed synchronously. This is minimal transparency.

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

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

A single, front-loaded sentence with no filler. For a one-parameter getter with an output schema, this is an appropriately concise size; every word earns its place.

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

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

For a simple tool with one parameter and an output schema, the description is almost sufficient. However, it lacks context about document prerequisites, how doc_id is obtained, and how this tool relates to overlapping siblings. It is adequate but has clear gaps.

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

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

Schema description coverage is 0% and the description never explains doc_id. The parameter name and schema title 'Doc Id' allow some inference, but the description adds no meaning beyond what the schema already provides, and it does not compensate for the missing schema descriptions.

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 ('Get') and resource ('total page count of the document'), making the core purpose unambiguous. It does not explicitly differentiate from siblings such as get_document_info or get_page_text, but 'page count' is distinct enough that the purpose is 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 provides no guidance on when to use this tool versus alternatives, no exclusions, and no mention of prerequisites. An agent must infer usage from the tool name alone, with no help from the description.

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

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

With no annotations provided, the description carries the behavioral burden. It does disclose the important 1-based page-number behavior, and 'Get' implies a non-mutating read operation. However, it does not say what happens for an invalid page number or whether the returned text includes tables, headers, or other page elements.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, and the critical page-number detail is placed in a concise parenthetical.

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 page-specific getter, the description is close to adequate: the output schema exists and page_number semantics are clarified. However, the unexplained 'option' parameter and lack of alternative-tool routing leave meaningful gaps for an agent selecting and invoking this 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 0%, and the description only clarifies page_number semantics by noting it is 1-based. The required doc_id parameter and the optional 'option' parameter are not explained at all, leaving an agent guessing about what doc_id refers to and what option controls.

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

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

The description names a specific verb and resource: 'Get text content of a specific page'. The parenthetical '1-based page number' adds a useful constraint that helps distinguish this tool from siblings like get_document_text, which returns whole-document text. It does not explicitly contrast with siblings, but the page-level scope is clear enough to avoid obvious confusion.

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

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

There is no guidance about when to use this tool versus alternatives such as get_document_text or get_paragraphs. The description only states what the tool does, not when an agent should prefer it or when it should not be used. This leaves routing 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 states it returns a list of paragraphs with text and index, which is basic behavioral info. However, with no annotations, it doesn't explicitly disclose side effects (none implied), error conditions, or scope like whether it covers the entire document. It's neutral but not comprehensive.

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

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

The description is a clean docstring with Args and Returns sections, concise and front-loaded. Every sentence contributes meaning without verbosity.

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 output schema exists and the tool is a simple reader, the description covers purpose, parameters, and return format. It lacks usage differentiation relative to siblings and doesn't mention edge cases, but it's adequate for 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?

The description fully explains all three parameters, clarifying doc_id as from open_document, start as the starting index, and limit as the maximum return count. Since schema coverage is 0%, this is essential and well done.

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 retrieves paragraphs from a document, specifying the action and resource. It is distinct enough from siblings like get_document_text or get_page_text, but it doesn't explicitly differentiate them, so it doesn't earn a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention exclusions or prerequisites beyond referencing open_document, so an agent has no explicit direction on selecting this over similar text-retrieval tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read operation but does not state side effects, required document state, failure modes, or what 'list/para/pos set' means behaviorally. The description adds little beyond the basic purpose.

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 in the first sentence and the parameter explanation immediately following. There is no filler or redundant restatement of the tool name.

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

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

For a simple getter with one parameter and an output schema, the description is minimally sufficient: it names the purpose and the doc_id source. However, it lacks usage context and behavioral details, which leaves some ambiguity around when this tool should be chosen over similar position-related 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?

The schema provides no description coverage for doc_id beyond its type, but the description adds a meaningful hint: 'Document ID from open_document.' This compensates partially by identifying the expected source of the parameter, though it does not explain formats or how to obtain the ID beyond that.

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 action and resource: 'Get current cursor position as list/para/pos set.' It clearly identifies what the tool does and gives a useful output shape. It does not explicitly differentiate from sibling tools like get_cursor_position or get_selected_pos_by_set, which keeps it from a 5.

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

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

The description gives no guidance on when to use this tool versus alternatives such as get_cursor_position, set_pos_by_set, or get_selected_pos_by_set. There is no mention of prerequisites or context beyond doc_id. This is essentially no 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?

No annotations are provided, so the description must carry the behavioral transparency burden. While 'Get' implies a read operation, the description does not explicitly state that the script is not executed, does not mention error behavior for missing scripts, and gives no side-effect or safety context. This is a meaningful gap for an unannotated 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 appropriately minimal: one clear purpose sentence plus a compact Args block. There is no filler or redundant restatement of the schema, and the key action is front-loaded.

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

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

For a simple two-parameter tool with an output schema present, the description covers the essential inputs and their provenance. The main missing piece is explicit side-effect or exclusion guidance, but an agent can successfully invoke the tool with the provided doc_id and name.

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 0% and the schema only provides generic titles ('Name', 'Doc Id'), so the description must compensate. It does by explaining doc_id as the ID from open_document and name as the script name to retrieve. This gives the agent enough semantic grounding, though format or source details for the name are not included.

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: getting the source code of a named script. This distinguishes it from siblings like run_script or run_macro, which execute rather than retrieve. The scope is clear enough that an agent knows what the tool does immediately.

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 Args section gives useful context by tying doc_id to an open document, which implies a prerequisite of opening the document first. However, it does not explicitly say when to use this tool versus alternatives, nor when not to use it, so the usage guidance is present but incomplete.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Get' strongly implies a read-only operation and identifies the target as the current selection, but it does not say what happens when no selection exists or whether any state changes occur. For a simple getter, this is minimally serviceable but not richly 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 compact and front-loaded: the purpose sentence appears first, and the parameter note is a single useful line. There is no filler or 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 one-parameter, read-oriented tool with an output schema, the description provides enough information to locate the document and understand the operation. The main omission is usage differentiation among sibling tools, but that gap is already reflected in the usage_guidelines dimension.

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 only says doc_id is a required string, so the description's note that it is the Document ID from open_document adds the essential semantic context. Since there is only one parameter, this fully compensates for the 0% schema description 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 ('Get') and an explicit target ('selected range start and end positions'), so the core function is immediately identifiable. It does not explicitly differentiate from close siblings like get_pos_by_set or get_selection_info, but the phrase 'selected range' provides reasonable scoping.

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

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

There is no guidance about when to choose this tool over alternatives such as get_pos_by_set or get_selection_info. The only contextual hint is that doc_id comes from open_document, and the selection prerequisite is merely implied by the word 'selected' rather than stated.

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

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

With no annotations, the description carries the full burden. The word 'Get' implies a non-mutating read operation, which provides some transparency, but the description does not disclose behavior for edge cases like an empty selection, invalid doc_id, or whether any document state changes.

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

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

The description is a single concise sentence with no filler or repetition. It is appropriately front-loaded but is perhaps too terse to carry the behavioral and contextual information expected for a tool with no annotations.

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

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

For a tool with no annotations and many closely related siblings, the description is too thin. It does not explain what the returned 'information' contains, when to prefer this over other selection tools, or what preconditions apply. An output schema exists, which likely covers return structure, but it does not compensate for the missing usage 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 0%, and the description does not explain the role of doc_id at all. The parameter name and title are self-explanatory as a document identifier, but the description fails to connect it to the 'current text selection' or explain why it is required.

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 identifies a getter operation for the current text selection, using a specific verb and resource. However, it does not specify what aspects of the selection are returned, so it remains somewhat vague and does not fully distinguish itself from selection-related siblings like get_selected_pos_by_set.

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 usage context is provided. The description does not state when to use this tool versus the many selection- and document-related siblings, nor does it mention any preconditions such as needing an active document or an existing selection.

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

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

With no annotations, the description carries the burden of explaining behavior. It discloses the return format and that it reads the full table, but does not mention read-only guarantees, error behavior, or how merged/empty cells are represented.

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 well-structured: a one-sentence summary followed by Args and Returns. Every line adds relevant information with no wasted words.

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

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

For a simple two-parameter getter with an output schema, the description is mostly adequate. It omits the indexing convention and does not point the agent to get_tables for discovering table_index, but otherwise covers what the agent needs to invoke 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?

Schema description coverage is 0%, so the description must compensate. It gives useful provenance for doc_id ('from open_document'), but table_index is only described as 'Index of the table,' restating the parameter name without specifying whether it is zero-based or how it relates to get_tables.

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: 'Get full table data as a 2D array.' It clearly identifies the input document and table index, making it distinct from related tools like get_tables or table_to_text.

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 intended usage: after opening a document, pass its doc_id and a table index to retrieve cell data. However, it does not explicitly say when to prefer this tool over alternatives or provide 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?

With no annotations, the description must carry the behavioral burden. It states the return is a list of tables with metadata, but does not disclose what metadata is included, whether the operation is read-only, what happens with no tables, or any error conditions.

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 main verb/resource, and organized with Args/Returns sections. Every line adds information 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 one-parameter read/list operation, the description covers the essential input and a vague return type. However, it omits what 'metadata' contains and how the returned table references relate to sibling tools such as get_table_data, leaving an agent without full context for downstream calls.

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 0%, but the description compensates by explaining that doc_id comes from open_document, which is critical for obtaining it. It does not detail the ID format, but for a single parameter this is meaningful guidance beyond the raw 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 clear verb/resource ('Get tables from the document') and clarifies the return shape ('List of tables with metadata'), which distinguishes it from related tools like get_table_data. It does not explicitly name the sibling alternative, so it falls just 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?

The only usage context is 'doc_id: Document ID from open_document,' which hints at a prerequisite but gives no guidance about when to choose get_tables over get_table_data or other table tools. No exclusions or alternative conditions are provided.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it only says 'Execute HWP action' and 'Properties to set.' It does not state whether the operation mutates the document, requires permissions, is reversible, or what the action invocation actually does with the parameter 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 longer than average, but the parameter-set list is structured and earns its place because the schema provides no enums or descriptions. The core operation is front-loaded and the Args section clearly maps to schema fields.

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 nine parameter-set variants and no schema descriptions, the list of supported sets and properties is valuable and mostly adequate. It remains incomplete because it does not explain how action_name should be chosen, whether params are required for setting vs reading, or provide any example call, and the output schema only mitigates the return-value gap.

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

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

Schema coverage is 0%, and the description compensates by explaining doc_id, action_name, param_set_name, and params, plus the valid properties for each supported parameter set. It falls short of a 5 because valid action_name values and the exact mapping between actions and parameter sets are not specified.

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 concrete verb and resource: it executes an HWP action using a document-info HParameterSet, and it enumerates the supported doc-info parameter sets. This clearly distinguishes its domain from sibling param-action tools, though 'HWP action' remains generic without examples of valid action names.

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 'Must be one of the doc info param sets listed above' constraint and supported-parameter-set list imply when this tool is appropriate. However, it does not explicitly say when to prefer this over run_hwp_action, get_document_info, or the sibling hwp_*_param_action tools.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It explains what parameter sets are supported but does not disclose whether the action mutates the document, what side effects occur, whether permission or an open document is required, or what errors may result. This is a significant gap for an execution 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 front-loaded with the core purpose, then uses a scannable bullet list that earns its length by documenting many valid param sets. There is no filler or redundant restating of the schema, and the structure makes it easy for an agent to locate the relevant param set properties.

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 complex, with free-form params and no annotations, and the description does a good job enumerating param sets. However, it does not explain the relationship between action_name and param_set_name, does not list valid action_name values, and gives no examples or prerequisites beyond doc_id. An agent could understand the param set vocabulary but would still struggle to confidently invoke the correct action.

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 0% schema description coverage, the description compensates well by enumerating all supported param_set_name values and listing key properties plus enums/type hints. doc_id and params are also described. However, action_name allowed values are not provided, and the property lists are labeled as 'key' rather than exhaustive, which leaves some ambiguity for free-form params.

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 executes an HWP action using draw/shape-related HParameterSet objects. It differentiates from table/file/style param actions by enumerating HDraw* param sets. However, it slightly overlaps with sibling hwp_shape_param_action, since both involve shape-related functionality, so it is not perfectly distinctive.

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: use this tool when draw/shape-related HParameterSet operations are needed, and param_set_name must be one of the listed values. It does not explicitly state when not to use it, nor does it name alternatives like run_hwp_action or hwp_shape_param_action, leaving some routing 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?

There are no annotations, so the description carries the behavioral burden. It discloses the conversion operation and enumerates accepted enum_type values, which is useful. It does not mention behavior for invalid values, case sensitivity, or error handling.

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 purpose, and every section earns its place: the purpose statement, supported enum types, and parameter definitions. There is no redundant or vague wording.

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 an output schema present, the description need not explain return values. For a two-parameter conversion utility, it gives purpose, supported enum types, and parameter meanings. The main gap is the lack of error-behavior guidance and usage context, but overall it is usable.

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 0%, and the description compensates with an Args section explaining both enum_type and value. It also lists allowed enum_type categories. It could add examples of valid enum member strings, but the provided meaning is 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 states a clear verb and resource: 'Convert string to HWP enum value.' It also lists supported enum_type values, making the tool's scope concrete. It does not explicitly distinguish itself from sibling tools, but the unique conversion purpose is still evident.

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 when to use the tool by listing valid enum_type categories, which gives an agent concrete direction. However, it does not explain when not to use it, mention alternatives, or describe 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It describes mechanics of param sets but does not mention side effects, permissions, reversibility, or failure behavior, despite covering potentially destructive operations such as HFileSaveAs, HFileConvert, HFileSendMail, and overwrite flags.

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 clear purpose sentence, then organized into compact bullets and an Args block. The length is justified by the large number of supported param sets, and each entry contributes information an agent would need.

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

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

The tool has an output schema, so return-value documentation is not necessary, and the description provides a comprehensive catalog of param sets. However, significant gaps remain: there is no mapping from action_name to param_set_name, no prerequisites for doc_id on all operations, and no warnings about destructive or side-effecting actions. For a generic executor over HWP's rich file operations, this is a meaningful but not fatal 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 0%, and the description compensates well: it explains doc_id, action_name, param_set_name, and params, and lists the key properties of each supported file param set with type hints for several values. It does not enumerate valid action_name values or which actions pair with which param sets, but the parameter meaning is largely clear.

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

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

The description clearly states the action ('Execute HWP action') and the resource class ('file-related HParameterSet'), and enumerates specific param set names such as HFileOpen, HFileSaveAs, and HFileConvert. This distinguishes it from sibling param-action tools at least by domain, though it does not explicitly contrast itself with them.

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

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

No guidance is given about when to use this generic file-param executor versus dedicated tools like open_document, save_document, get_file_info, or the sibling hwp_table_param_action / hwp_draw_param_action tools. The phrase 'file-related' implies scope but does not provide selection criteria 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?

No annotations are present, so the description carries the full burden of disclosing side effects. It only states that it executes an action and sets properties; it does not say whether this mutates the document, whether actions like HFormPushButton.OnClick can trigger scripts, or what result to expect. This is a significant transparency gap for an 'execute action' 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 purpose is front-loaded, and the long block of form-control variants is formatted as scannable bullets where each line adds distinct property information. There is no filler or 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 high-variance tool with a bare schema, the parameter table is a strong contribution and the output schema covers return shape. But the description omits action_name semantics, side effects, and any usage exclusions, so an agent still has to guess at some call requirements.

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