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

No annotations are provided, so the description alone must disclose behavior. It states the tool writes a new file, which implies it does not modify the original, but does not clarify side effects, permissions, or what 'delegate' means. Key behavioral aspects like whether the source document is altered remain ambiguous.

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 short sentence, which is concise but lacks essential information. It does not waste words, but it could be slightly expanded to improve clarity without losing conciseness.

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 5 parameters, no annotations, and an output schema (not shown), the description is insufficient. It fails to explain key parameters like path and dimension properties. The agent cannot properly construct a valid call without additional inference.

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 has 5 parameters with 0% description coverage. The description mentions image_path (image file) and out_path (new file), but does not explain path (likely source document) or the optional width_mm and height_mm. The description adds minimal value beyond the 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 clearly states the action (insert an image file) and the output (write a NEW file). The verb 'Insert' and resource 'image file' are specific. However, the parenthetical '(delegate)' is unclear and does not aid agent understanding. The distinction from sibling tools like add_paragraph or add_table is implicit but not explicit.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, when not to use, or refer to any sibling tools. The agent receives no context for tool selection among the many sibling tools listed.

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?

Discloses that it is a delegate to python-hwpx and involves reserialization and re-validation after. However, it omits details like whether it overwrites existing files, required permissions, or side effects on the original file.

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 sentence, which is concise, but it packs multiple concepts (delegate, reserialize, re-validate) without clear structure. Could be more readable with separation into two sentences.

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

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

Despite having an output schema, the description fails to cover important parameters like section_index and does not explain the return value or error conditions. It is incomplete for a tool with 4 parameters and no schema description coverage.

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

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

With 0% schema description coverage, the description must explain parameter meanings. It only mentions 'text paragraph' but does not clarify path, out_path, or section_index. The schema provides default for section_index but description adds no semantics.

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

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

The description clearly states the verb 'Append' and resource 'a text paragraph', and specifies it writes a NEW file. It distinguishes from sibling tools like add_image or add_table by focusing on paragraph addition and file creation.

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

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

No explicit guidance on when to use this tool versus alternatives. The phrase 'write a NEW file' implies it creates new files rather than modifying existing ones, but no comparison with siblings is 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?

The description lacks disclosure of important behaviors: it does not confirm whether the input file is modified (it says 'new file', but the verb 'append' implies modification), does not mention overwrite behavior, permissions, or size limits. The phrase 'python-hwpx delegate' is cryptic and offers no behavioral clarity.

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 sentence, which is concise, but it sacrifices necessary detail. It front-loads the action but lacks structure to convey parameter roles or usage 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?

Given 4 required parameters with no schema descriptions, an output schema exists but is not referenced, and many sibling tools for similar tasks, the description is insufficient. It does not explain what each parameter does, what the tool returns, or how it differs from alternatives.

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 explain parameters, but it only hints at rows and cols ('rows x cols') and completely omits explanation of path (input file?) and out_path (output file?). The agent must infer semantics without sufficient context.

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 specific verb-resource pairs 'Append a rows x cols table' and 'write a NEW file', clearly indicating the tool adds a table and saves to a new file. However, it doesn't explicitly state that it appends to an existing document (via path) and whether the table is placed at the end or elsewhere, leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus siblings like create_hwpx_table or add_image. There is no mention of prerequisites, alternatives, or conditions for use, making it hard for an agent to decide correctly.

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

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

With no annotations, the description must fully disclose behavioral traits. It only states the detection targets but does not cover side effects, permissions, data persistence, or return format. The read-only nature is implied but not explicit.

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 (one sentence), but it front-loads the core purpose. However, it lacks structure (e.g., no parameter section) and feels incomplete.

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 one parameter and an output schema, but the description does not clarify what the output contains, nor does it explain the term 'FILE MODE'. More context is needed for a complete understanding.

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 does not mention the single required parameter 'path' at all. Schema coverage is 0%, so the description fails to add meaning to the 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 clearly states the tool's verb 'detect' and resource 'fillable fields', listing specific types. However, 'FILE MODE' is ambiguous and it does not explicitly differentiate from sibling tools like 'analyze_formfit'.

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. No mention of prerequisites, file requirements, or 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?

With no annotations, the description must disclose all behavioral traits. It only says 'estimate', implying read-only, but provides no detail on side effects, permissions, or error conditions. 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?

The description is a single sentence, achieving conciseness but at the expense of completeness. It is not verbose, but lacks sufficient detail.

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 does not explain what the tool returns or how the output relates to the input. For a tool with two required parameters and nested objects, this is 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%, yet the description adds no information about the parameters ('path' and 'values'). The agent must rely solely on the schema, which lacks 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 clearly states the tool estimates overflow/fit risk for candidate values against detected field capacity. It uses a specific verb and resource, though it does not distinguish from sibling 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?

No guidance on when to use this tool versus alternatives, nor any context for its application. The description lacks usage prerequisites 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?

With no annotations, the description carries full burden. It discloses that the tool does not mutate the open Hangul window, keeps repeated text explicit with structural scope, and that the plan came from structural addresses. This is comprehensive 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 verbose at ~150 words with multiple long sentences. It could be more concise by trimming redundant explanations about structural scope and repeated text. The first sentence is good, but the rest is dense.

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

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

Given the tool's complexity and 2 required params, the description adequately covers purpose, context, and behavioral traits. An output schema exists to cover return values. The description addresses when to use and what not to do, making it complete for task 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?

Schema description coverage is 0%, so description must add meaning. It explains that session_id comes from preview_addressed_edits and out_path is required. While minimal, it clarifies the role of each parameter, though no format or constraints are 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 clearly states 'Write the previewed addressed edits to a NEW file-mode output copy,' providing a specific verb and resource. It distinguishes from siblings like apply_to_current_hwp_document by emphasizing file-mode output and no mutation of open windows.

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 guidance: use after preview_addressed_edits, gather all values first, and avoid mixing with live field writes. It implies this is for file-mode, not for open documents, but does not explicitly list sibling 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?

Without annotations, the description should disclose behavioral traits. It mentions 'atomically' but does not specify mutation scope, required permissions, or side effects. Insufficient 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?

A single sentence, concise and front-loaded. However, it uses jargon ('safe root') that may obscure meaning. Still earns a high score for brevity.

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, the description fails to explain critical context: what a 'three-variant assessment bundle' is, what 'safe root' means, and what the parameters represent. Incomplete for a tool with three required params and no schema descriptions.

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 provides no explanation of the three required parameters (session_id, possession_token, output_dir). The agent cannot infer what values to provide.

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 atomically publishes a reviewed three-variant assessment bundle. It distinguishes from sibling 'preview_assessment' and other apply tools by specifying the atomic, reviewed, three-variant nature.

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

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

No explicit guidance on when to use this tool versus alternatives. No when-not or alternative tool mentions, leaving the agent to infer usage context from the description 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 carries full burden but only says it writes a new file with journal/snapshot. It does not disclose side effects (e.g., whether the preview session is consumed), required permissions, or behavior when out_path is empty. The 'journal/snapshot' jargon is ambiguous.

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 sentence with 14 words, making it very concise. However, the phrase 'with journal/snapshot for restore' could be clearer. No structural issues, but it sacrifices completeness for brevity.

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, the description is incomplete for a write tool with two parameters. It lacks details on error handling, output file naming, and the journal/snapshot mechanism. For a medium-complexity tool, it leaves significant 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 adds no meaning to the parameters. It does not mention session_id (required) or out_path (optional), leaving the agent to infer their purposes from context alone. This is a critical gap.

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

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

The description clearly states the tool writes a previewed edit session to a new file with journal/snapshot for restore. It uses a specific verb ('write') and resource ('previewed edit session'), distinguishing it from siblings like 'apply_to_current_hwp_document' which modifies existing documents.

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

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

The description implies usage when you want to save a previewed edit as a new file, contrasting with siblings that apply edits to existing documents. However, it does not explicitly state when not to use it or provide alternative tools, nor does it mention prerequisites like having a valid session_id.

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 provided, so description carries full burden. It discloses cold start latency, path verification, and attachment behavior, but could mention more about return value or error states.

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?

Well-structured with front-loaded purpose and clear exclusions, but could be slightly more concise. Still earned its length.

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

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

Covers purpose, usage, and behavior, but lacks parameter details. Assuming output schema provides return info, it's still not fully complete for an exhaustive agent understanding.

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 description only minimally explains 'open_if_needed' and 'clear'. The 'values' dictionary, 'visible', and 'path' parameters are not described, leaving significant gaps.

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 it fills a small set of label:value cells in the open Hangul window, differentiating from whole-template completion tools like complete_addressed_template.

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

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

Explicitly states when not to use (whole-template completion) and directs to alternative tools, with a recommendation to preview first.

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. It discloses that the token is authoritative, revalidation occurs, and differentiates between mutating the live document versus creating a new file with complete_and_load tokens. It also notes what the tool does not expose. This adds meaningful 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 a single paragraph that front-loads the main action. Every sentence adds value, though the second sentence is dense with two behavioral modes. Overall, it is efficient and avoids fluff.

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 (one parameter, no annotations, output schema present), the description covers purpose, parameter semantics, and key behavioral distinctions. It implicitly assumes the agent knows to preview first. Explicit error conditions or side effects are not stated, but the output schema likely handles return values.

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 for preview_token has 0% description coverage. The description fully compensates by explaining the token's role: a previously previewed pathless current-document edit, and further distinguishes between token types. This adds significant meaning 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 clearly states it applies a previously previewed pathless current-document edit by token. It differentiates between normal apply and complete_and_load tokens. However, it does not explicitly distinguish this tool from sibling apply tools like apply_addressed_edits or apply_edit_session, which share a similar prefix.

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

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

The description explains the token-based invocation and mentions revalidation before mutation. It also notes the absence of a timeout_seconds worker-isolation contract. However, it does not specify when to use this tool versus alternatives, nor does it explicitly state prerequisites like 'must have previewed'.

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 full behavioral disclosure. It explicitly states that only value insertion is supported, no formatting live, details two modes (pathless vs broker-targeted), refuses to guess across brokers, and notes the lack of a timeout contract. This gives the agent a clear understanding of behavior and limitations.

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 main purpose and adds detailed but relevant information in subsequent sentences. It avoids redundancy or filler, but could be slightly more concise by combining some clauses. Still, it efficiently conveys necessary information.

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

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

Given the tool has three parameters and an output schema, the description covers purpose, behavior, modes, and limitations. It does not mention prerequisites (e.g., document must be open) or error handling (e.g., missing fields), but these are somewhat implied by the domain. Overall, it provides sufficient context for correct invocation.

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

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

Schema description coverage is 0%, so the description must add meaning. It explains the 'path' parameter's dual mode behavior and clarifies that 'values' maps field names to strings. The 'visible' parameter is not mentioned, but its default true is self-explanatory. Overall, it compensates well for 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 clearly states the tool performs one-shot value fill of named form fields in the open Hangul window. It differentiates from file-mode delegate tools for formatting/styling, and mentions legacy pathless vs broker-targeted modes, establishing a distinct purpose among siblings.

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

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

The description provides when to use (value fill in open Hangul window) and when not (formatting/styling edits should use file-mode delegate tools). It also explains the two operation modes, but does not explicitly compare with all siblings like 'fill_form' or 'apply_to_current_hwp_document', leaving some ambiguity.

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 burden. It discloses that the operation is for text substitution only and produces a new file (non-destructive). However, it omits details like permissions needed, error cases (e.g., file not found), or whether substitutions are case-sensitive.

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 sentence with no wasted words. It efficiently conveys the core purpose and constraints, making it easy for an agent to parse.

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 creates a new file with multiple replacements, the description is too brief. It does not address edge cases, behavior on overlapping replacements, or return value (despite having an output schema). Siblings like search_and_replace likely offer more context, making this feel 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%, and the description does not explain the three parameters (path, out_path, replacements). The phrase 'find->replace pairs' loosely maps to the replacements object, but does not clarify the mapping or format. The description adds minimal value beyond the schema structure.

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 specifies the verb 'Apply', the resource 'multiple find->replace pairs', and important qualifiers: 'to a NEW file' and 'text substitution only'. This distinguishes it from siblings like search_and_replace or preview_batch_replace.

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

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

The description implies usage for creating a new file with substitutions applied, but does not explicitly state when not to use or suggest alternatives. The context of working on a 'NEW file' provides some guidance, but lacks exclusions like 'do not use on existing open documents'.

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 discloses that the tool 'writes out_path only and does not mutate the already-open same Hangul window,' and that edits use structural addresses. It also warns against treating repeated text as document-wide replace without explicit scope. This provides adequate behavioral transparency for a file-writing 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 a concise paragraph of 5-6 sentences, front-loaded with the purpose. It avoids unnecessary repetition and covers key points efficiently. While it could be slightly more structured (e.g., bullet points), it remains clear and well-organized.

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 complexity of the tool (4 parameters, nested AddressedEdit schema) and the large number of sibling tools, the description provides sufficient context. It explains the mode, output, address format, and key behavioral constraints. The output schema (not shown) likely covers return values, so the description is adequately 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?

The input schema has 0% description coverage for top-level parameters, but the description adds context: it explains that edits should be sent as one array, and that the tool writes a new copy to out_path. It also clarifies that 'edits do NOT require {} named fields; use structural addresses.' This adds meaning beyond the schema, compensating for the lack of parameter 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 clearly states the purpose: 'Complete a whole template in ONE addressed file-mode call and write a new copy.' It specifies the action (complete a whole template), the mode (addressed file-mode), and the output (write a new copy). It distinguishes itself from per-cell calls and live field writes, differentiating from siblings like apply_addressed_edits.

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 explicit usage guidance: 'Gather or generate all values first, then send one edits array here — not one call per cell.' It also advises to 'Start in file mode for whole-template completion instead of mixing live field writes and falling back to file mode later.' While it doesn't name specific alternatives, it clearly implies when to use this tool and what to avoid.

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 burden. It does not disclose what 'delegate' means, side effects, permissions, or output format. The output schema exists but is not referenced.

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 concise sentence with no extraneous content. Every part 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?

Given no annotations, 0% schema coverage, and an output schema, the description should provide more context. It lacks details on return values, side effects, and input constraints.

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%. The description only mentions 'ordered content blocks' but does not explain what blocks are or the meaning of 'out_path'. No parameter details are given.

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 (create), the resource (HWPX document), and the input (ordered content blocks). It effectively distinguishes from sibling tools like create_document_from_spec.

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 term '(delegate)' hints at delegation but is not explained, and no exclusions or prerequisites 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?

No annotations are provided, so the description carries full burden. It states a mutation ('Create') but lacks details on validation, side effects, permissions, or response behavior. The reference to 'validated template union' is vague.

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 at one sentence. It front-loads the primary purpose. However, it could be slightly more structured or include key behavioral hints without adding 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 high number of sibling tools and the presence of nested objects in the schema, the description is incomplete. It fails to explain the 'DocumentSpec v1' structure or how this tool differs from other document creation tools, leaving significant gaps for an AI agent.

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% with no descriptions in the schema. The tool description adds minimal context: 'DocumentSpec v1 payload' for spec and 'out_path' is self-explanatory, but spec structure and constraints remain unclear. For a complex object parameter, more detail 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 clearly states the action 'Create an HWPX', specifies the source 'DocumentSpec v1 payload', and distinguishes from sibling creation tools by mentioning 'validated template union; delegate', which implies a specific input format.

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

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

No explicit guidance on when to use this tool versus alternatives like create_document_from_blocks or create_hwpx_from_markdown. The phrase 'delegate' hints at internal usage, but no when-to-use or when-not-to-use instructions.

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. It only says 'create HWPX from Markdown' and hints at delegation via '(delegate)', but does not explain delegation, side effects (e.g., file overwriting), permissions, or return 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 very short (one phrase), which is concise but sacrifices completeness. It front-loads the key action but omits important details, making it insufficient for a 2-parameter tool with no parameter descriptions.

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 2 required parameters and no output schema details in the description, it lacks completeness. No mention of return values, error conditions, or relationship to 58 sibling tools. The description does not adequately guide selection or usage.

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

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

The description adds no meaning beyond the input schema. It mentions 'Markdown content' but does not clarify whether 'markdown' expects raw text or a file path (despite schema type 'string'), and 'out_path' is left unexplained. Schema coverage is 0%, and the description fails to compensate.

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 'Create an HWPX from Markdown content', which specifies the action and output format. However, the parenthetical '(delegate)' introduces ambiguity, lacking sibling differentiation and leaving unclear whether the tool directly performs creation or delegates.

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 guidance is provided. The description does not indicate when to prefer this tool over siblings like 'create_document_from_spec' or 'hwpx_to_html', nor any criteria for when not to use it.

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

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

No annotations provided and description does not disclose side effects, overwrite behavior, or authentication requirements. Only states basic function.

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?

Very concise single sentence that is front-loaded. However, the word 'delegate' is confusing and detracts from efficiency.

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?

Lacks details on row format, error handling, and output behavior. With no annotations and low schema coverage, incomplete for a tool with two required parameters.

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 description only adds 'from headers/rows' without explaining structure of rows parameter or behavior of out_path. Fails to compensate for 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?

Clearly states it creates a new HWPX file with one table from headers/rows. Distinguishes from siblings like add_table (adds to existing doc) and create_hwpx_from_markdown. However, 'delegate' is ambiguous and reduces 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?

No guidance on when to use this tool vs alternatives like add_table or create_document_from_blocks. Only states input format (headers/rows) without contextual advice.

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 full burden. It only mentions creation but does not disclose side effects, authorization needs, or what 'delegate' means. No indication of whether it is destructive or modifies existing 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 very short (one sentence) and front-loaded, but uses jargon ('gongmun', 'delegate') without explanation. It could be clearer while maintaining conciseness.

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 complexity (creating official documents with nested parameters) and the existence of an output schema, the description is incomplete. It does not explain what a 'skeleton' is, what 'delegate' implies, or how fields should be structured.

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%, yet the description does not explain parameters like 'fields' (expected keys) or 'out_path'. It merely mentions 'fields (delegate)' without clarifying their structure or purpose.

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 clearly states verb 'Create' and resource 'Korean official-document (gongmun) skeleton HWPX', specifying the operation. However, it does not distinguish from siblings like create_document_from_blocks or create_hwpx_from_markdown, lacking 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?

No guidance on when to use this tool versus alternatives. With many sibling tools for HWPX creation, the description fails to provide context for appropriate usage.

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. It transparently states the outputs (capability availability, tool buckets, runtime identity). As a read-only introspection tool, no side effects need mentioning.

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 clear front-loaded verb 'Report'. No wasted words, all content is essential.

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 0 parameters, no annotations, and an output schema, the description fully covers the tool's purpose and outputs. It mentions three concrete aspects of what is reported.

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?

No parameters exist, so baseline is 4. The description adds no parameter info, which is acceptable since schema coverage is 100% and there are no parameters to describe.

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 reports per-capability availability, tool buckets, and runtime identity. This distinguishes it from sibling tools focused on document manipulation.

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

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

The description implies usage for capability introspection. While no explicit when-not or alternatives are given, the sibling context makes it clear this is for querying system capabilities, not document operations.

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, and the description only states the detection purpose. It does not disclose side effects, permissions, or performance characteristics expected for a mutation-free inspection 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?

Single sentence with no filler words. Front-loaded with the verb 'Detect' followed by resource and outcomes.

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

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

No information about return values or output schema behavior. For a detection tool, the output meaning should be clarified.

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%. The description adds minimal context to the 'path' parameter beyond the schema's type definition, not specifying format 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?

Description clearly states the tool detects file format (HWPX, binary HWP, or unknown) with specific verb and resource. It distinguishes from sibling tools like extract_hwp_text or validate_hwpx.

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

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

No explicit when-to-use or when-not-to-use guidance. Usage is implied (detect format before processing), but no alternatives or exclusions are discussed.

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 discloses that the tool writes a new file, implying the original is unchanged. However, it lacks details on error behavior, pattern matching behavior, or how delegation works. With no annotations, this is minimal but not contradictory.

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 sentence with no unnecessary words. It efficiently conveys the core purpose and outcome.

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

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

For an 8-parameter tool with no annotations, the description is too brief. It does not explain how the 'find' pattern works, default values, output format (even with output schema), or edge cases like no matches. More context is needed for correct invocation.

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

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

Despite 0% schema description coverage, the description adds meaning to key parameters: bold, italic, underline, color, size, and find (matched text). It also implies path and out_path. This compensates well for 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 clearly states the tool applies bold/italic/underline/color/size to matched text and outputs a new file. This is a specific verb+resource combination that distinguishes it from sibling tools which modify existing documents or perform other operations.

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 like apply_to_current_hwp_document or search_and_replace. The description does not mention prerequisites, limitations, or typical use cases.

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 only behavioral trait disclosed is that it returns available:false until a non-COM reader is available. No annotations exist, so the description carries the full burden, but it fails to describe side effects, output format, 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 sentence, which is efficient in length, but its cryptic phrasing ('gate', 'lands') wastes the short space. It could be clearer without adding length.

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

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

Despite having an output schema, the description lacks essential context about the tool's current state (unavailable), what the output will contain, and any usage constraints. It feels 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?

The schema has 0% description coverage for the 'path' parameter, and the tool description provides no additional meaning about what path refers to (e.g., file path, URL, etc.). This is a critical gap.

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

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

The description states 'text extraction' for .hwp files, which clarifies the resource and action. However, the 'gate' and 'returns available:false' caveat muddles whether the tool is currently functional, reducing 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?

No guidance is provided on when to use this tool versus siblings like 'extract_text'. The description does not mention prerequisites, alternatives, or appropriate contexts.

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 is the sole source of behavioral information. It only states the return type (string) but omits details such as whether the operation is read-only, error conditions, encoding, or requirements for the input file.

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 sentence that directly communicates the core functionality. There is no unnecessary information, achieving maximum conciseness.

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 required parameter and an output schema, the description is too sparse. It lacks details on error handling, return format, and any prerequisites (e.g., file existence). While the tool is straightforward, completeness would require at least a note on limitations or typical use cases.

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 'path' is not described beyond what the schema provides. The description hints that the path should point to an HWPX file, but no additional semantic information (e.g., format, allowed locations) is given. Since schema coverage is 0%, the description adds minimal value.

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 ('Extract'), the resource ('HWPX file'), and the output ('returns a string'). However, it does not differentiate from the sibling 'extract_hwp_text', which likely serves a similar purpose for HWP files.

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 (e.g., extract_hwp_text for HWP files, or other text extraction tools). There is no mention of appropriate contexts or restrictions.

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 convey behavioral traits. It mentions 'byte-preserving' and 'new copy', implying non-destructive behavior, but does not disclose what happens on error, how parameters like dry_run, auto_fit, etc. affect behavior, or any side effects beyond file creation.

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 sentence with no redundancy. It is concise, but it sacrifices clarity on parameter semantics and usage context. Could be expanded slightly without losing conciseness.

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 10 parameters, zero schema descriptions, no annotations, and many sibling tools, the description is severely incomplete. It does not explain what the tool returns (though output schema exists), how the boolean flags interact, or how to handle edge cases like missing fields or invalid paths.

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 implicitly covers path, values, and out_path. The other 7 parameters (backup, dry_run, auto_fit, mask_pii, respect_bullets, normalize_spacing, checkbox_exclusive) are not explained at all. The description fails to add semantic meaning beyond the parameter names.

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 the tool fills detected named/label fields and writes a new byte-preserving HWPX copy. This clearly identifies the primary action and output, but it could elaborate on what 'fill' means or how fields are detected. It distinguishes from many sibling tools that perform other edits, but not from similar ones like apply_addressed_edits.

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. It does not mention prerequisites, limitations, or scenarios where other sibling tools 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?

The term 'locate' implies a read operation, but no explicit behavioral details are given (e.g., returns cell address or content, requires cell to exist). Since no annotations are provided, the description should compensate but does not.

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 at one sentence, but this brevity sacrifices clarity and completeness. It's not well-structured beyond being short.

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

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

Despite having an output schema, the description doesn't indicate what the tool returns (cell location? content?). For a relatively simple tool, it still lacks essential context for reliable use.

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 adds no meaning beyond the parameter names. It does not explain what 'path' (table path?) or 'label' (text of label cell?) represent, leaving the agent to guess.

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 'locate' and the resource 'input cell next to or under a label cell in tables'. It is specific enough to distinguish from many sibling tools, though it doesn't explicitly differentiate from similar find operations.

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 like get_table_map or find_text. No conditions or prerequisites are mentioned, leaving 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?

No annotations are provided, so the description carries the full burden. It indicates the tool operates in FILE MODE and counts matches, implying read-only behavior, but does not explicitly state side effects, permissions, or error conditions. Partial disclosure 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?

Single sentence that is front-loaded with the purpose. No wasted words; every part is meaningful.

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

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

An output schema exists (not shown), so return values are presumably covered. However, the description lacks explanation of 'FILE MODE' and how the count is returned (per cell or aggregate). With two parameters and no schema descriptions, the context feels slightly 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 implicitly references path and query but adds minimal detail beyond the parameter names. No format, constraints, or usage examples are provided, leaving ambiguity.

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 counts plain-text matches per cell in FILE MODE, using a specific verb and resource. It also distinguishes from the sibling tool find_text_occurrences by specifying the use case for structural addresses.

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

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

Explicitly says when to use this tool (FILE MODE) and when to use an alternative (find_text_occurrences for structural addresses), providing direct 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 provided, but the description explains the tool's mode ('FILE MODE'), states it does not mutate the already-open Hangul window, and clarifies it returns structural addresses for subsequent editing tools. It implies it is a read-only find operation, which is transparent. Would benefit from explicitly stating it does not modify 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 structured with a clear lead sentence, then context, usage conditions, and workflow. Every sentence adds value, though it is slightly verbose with the inline references to other tools. Could be tightened, but overall efficient for the information provided.

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 presence of an output schema (so return details are covered elsewhere), the description adequately covers what the tool does, when to use it, and how it fits into a larger workflow. It mentions 'structural addresses' but does not detail their format; however, the agent can infer from the output schema. The description is complete for deciding to invoke this 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%, and the description does not elaborate on the 'path' and 'query' parameters. While 'path' is implied by 'FILE MODE' and 'query' as the text to find, there is no detail on expected formats, valid values, or how to specify the query (e.g., plain text vs. regex). This leaves the agent guessing.

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 'Locate repeated visible text' and specifies the resource ('FILE MODE') and goal ('so edits can be scoped, not guessed'). It distinguishes from blind text replace and aligns with sibling tools like 'find_text' by emphasizing structural addresses.

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

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

Explicitly describes when to use (template with repeated markers, table cells), what not to do (global replace without scope), and the complete workflow: get occurrences, then use 'preview_addressed_edits' and 'apply_addressed_edits' or 'complete_addressed_template'. Provides clear alternatives and next steps.

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 does not state whether the operation is read-only, requires the document to be open, or has any side effects. Only the output type is implied.

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 uninformative sentence. While it is concise, it lacks essential details about parameters and behavior, making it inadequately specified rather than efficiently written.

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, the description does not explain what the outline structure contains (e.g., hierarchy levels, headings) or any prerequisites. It fails to provide sufficient context for correct usage.

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

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

Schema description coverage is 0%, and the description does not explain the single parameter 'path' (e.g., file system path or URL). It adds no value beyond the schema's type declaration.

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 returns the heading/outline structure of an HWPX document, specifying the verb 'Return' and the resource. It distinguishes itself from sibling tools like 'extract_hwp_text' or 'get_paragraph_map' by focusing on structure rather than content.

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 such as 'extract_text' or 'get_paragraph_map'. There is no mention of prerequisites, exclusions, or typical use cases.

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 burden. It indicates a listing operation (non-destructive), but does not explicitly state read-only behavior, permissions, or other side effects. The description is adequate but not thorough.

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 is front-loaded with the key action. However, it could be slightly expanded to clarify the parameter without losing conciseness.

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 presence of an output schema (not shown), the description does not need to detail return values. However, the lack of parameter explanation and usage guidance means the description is only moderately complete for such a simple 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%, meaning the schema provides no explanation for the single parameter 'path'. The description does not clarify what 'path' refers to (file path, document path, etc.), leaving the agent to infer. The description adds no semantic value over the schema.

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

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

The description clearly states the action ('List') and the resource ('body paragraphs'), along with a specific qualifier ('stable bN addresses for addressed edits'). This distinguishes it from sibling tools like get_table_map and get_document_outline.

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 tool is used when needing body paragraphs for addressed edits, but it does not explicitly state when to use it over alternatives, nor does it provide any exclusions or 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?

No annotations are provided, and the description does not disclose behavioral traits such as whether the tool is read-only, performance considerations, or error conditions. The description carries the full burden for transparency but fails to add meaningful 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 extremely concise at one sentence, but it sacrifices essential details. It is front-loaded but not sufficiently informative for an agent to use it correctly.

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 one parameter and an output schema (unseen), the description partially covers the purpose. However, it lacks completeness in explaining the input, output, and use case. The sibling context shows many related tools, and the description does not differentiate enough.

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 'path' has 0% schema description coverage, and the tool description does not explain what 'path' refers to (e.g., file path, document ID). With no parameter documentation elsewhere, the description should clarify the parameter semantics.

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

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

The description specifies mapping tables with per-cell text and merge structure, and connects to label-to-cell reasoning. It clearly distinguishes the tool from siblings like add_table or merge_table_cells, but could be more explicit about the output format.

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

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

No guidance on when to use this tool versus alternatives like get_paragraph_map or other table-related tools. With many sibling tools, the lack of usage context is a significant gap.

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

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

No annotations are provided, so the description carries full burden. It explicitly states the tool is 'side-effect-free, never launches Hangul', and explains that 'connected:false is the NORMAL idle state' with no attach attempted. This is sufficient transparency for a probe 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 brief (three sentences) and front-loaded with the core purpose. Every sentence adds essential 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?

Given the tool's simplicity (no parameters, side-effect-free probe) and the presence of an output schema (context signals), the description covers the core behavior and output meaning adequately. However, it could have elaborated slightly more on the output schema fields if needed.

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?

There are no parameters (0 params, 100% schema coverage), so baseline is 4. The description adds value by explaining the output fields (connected, instances) and their meanings, which aids understanding beyond the empty schema.

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

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

The description clearly states it is a 'Live COM availability probe' that is 'side-effect-free, never launches Hangul'. It distinguishes from sibling tools by explaining that it does not attach or open documents, and instead advises to use open_in_hwp(path) for attaching.

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

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

The description explains when to use the tool (to check COM status) and when to use alternatives ('Attach by exact path first (open_in_hwp(path))'). It does not explicitly state exclusions but provides clear 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 provided; description only mentions the method (python-hwpx) but omits behavioral traits like formatting preservation, limitations, 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?

Single concise sentence front-loads the core information; however, it is slightly too brief missing some context that could be added 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?

Description lacks essential details about input constraints, output format, error scenarios, and prerequisites beyond a vague mention of delegate extra. The presence of an output schema is noted but not exploited.

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 has one parameter 'path' with no description; tool description adds no additional meaning to the parameter, leaving its semantics 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?

Description clearly states the action (convert) and resources (HWPX to HTML), and notes the use of python-hwpx delegation. This distinguishes it from sibling tools like hwpx_to_markdown.

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?

Only minimal guidance is given via 'delegate extra required', implying a prerequisite but no explicit comparison to alternatives or when to use this tool versus similar ones.

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?

Only mentions delegation to python-hwpx, but no details about error handling, permissions, or side effects. Without annotations, more behavioral context is needed.

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?

Single sentence, no wasted words. However, it could include more context without losing conciseness.

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, the description is too terse. Lacks details on path format (local/remote), expected file extensions, and output characteristics even though output schema exists.

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 does not explain the 'path' parameter beyond its name. Schema coverage is 0%, so description must compensate but fails to add any meaning.

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

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

Clearly states the tool converts HWPX to Markdown, using a specific library. Distinguishes from sibling tool hwpx_to_html which converts to a different format.

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

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

No guidance on when to use this tool versus alternatives like hwpx_to_html. No when-to-use or when-not-to-use conditions.

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

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

No annotations provided, but the description reveals that the tool operates on file-mode, does not mutate the open window, and produces a completed copy. This is fairly transparent, though it could explicitly state read-only 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 front-loaded with the core purpose and provides essential usage guidance. It is not overly verbose, though the dense technical information could be slightly restructured for clarity.

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 complexity and many sibling tools, the description covers purpose, usage context, behavioral notes, and relationship to other tools. Output schema handles return values, so no further detail needed.

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 should explain parameters. However, it does not mention 'path' or 'compact'. While 'path' is implied by file-mode context, 'compact' remains unexplained, leaving the agent guessing.

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 inspects file-mode structural edit targets before writes. It distinguishes itself from siblings like apply_addressed_edits and complete_addressed_template by specifying its role as a preparatory step.

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 explicitly tells when to use structural addresses (for repeated elements, table cells, etc.) and warns against global replace without scope. It also names the appropriate follow-up tools (preview_addressed_edits, apply_addressed_edits, complete_addressed_template).

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 fully disclose behavior. It only states the tool lists style definitions, but omits critical details such as whether it is read-only, what happens if no document is open, or the structure of the output. The abbreviations 'charPr' and 'paraPr' may be unclear to some agents.

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 sentence with no superfluous words, efficiently communicating the core purpose. However, it is too terse and could benefit from additional context 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?

Despite having one parameter and an output schema (not detailed here), the description lacks essential context such as the return format, error scenarios, and the exact meaning of 'charPr/paraPr'. The agent cannot reliably determine how to use the tool or interpret its results.

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 for the 'path' parameter, and the tool description does not explain its meaning or format. The parameter's role is completely unspecified, forcing the agent to guess whether it refers to a document file path or an internal path to styles.

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 specific verb 'List' and resource 'charPr/paraPr style definitions', clearly distinguishing it from sibling tools which focus on other operations. The phrase 'in the document' implies the current open document, making the tool's 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 provides no guidance on when to use this tool versus alternatives, nor does it specify prerequisites or conditions. It simply states the action without any contextual usage advice.

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 provided, so description fully discloses behavior: uses Hangul's TableSubtractRow, recomputes merges, plans purely first, fails closed, deletes bottom-up, cold start delay. No contradictions.

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?

Concise with effective structure, front-loads purpose. Every sentence adds value, though a bit dense. Could be slightly more streamlined.

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 complexity and lack of annotations, the description covers purpose, constraints, behavior, and main parameter. Lacks explanation for path and visible, but output schema exists and cold start note is helpful.

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?

Rows parameter is well explained with format and example. Path and visible parameters are not described. Schema coverage is 0%, so description partially compensates but leaves gaps.

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?

Clearly specifies that the tool deletes table rows in the open Hangul window, live-only, with address format 'tN.rN'. Distinguishes from offline deletion which is unsafe.

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?

Describes when to use (live-only, open window) and when not (offline unsafe). Notes failure modes (nested tables, unknown rows, duplicates) and that it never opens/saves/closes the document. No explicit alternative tool names, but context is clear.

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

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

No annotations are provided. The description mentions a proprietary engine but does not disclose side effects, read/write nature, permissions, or limitations. For a generation tool, it is likely non-destructive but unspecified.

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, which is concise but lacks structure. It covers the core action and engine but omits important details about parameters and usage 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?

Given the tool generates multiple outputs from a template, the description is too minimal. There is no mention of error conditions, output format, or prerequisites. The presence of an output schema mitigates some need for describing return values, but other aspects are lacking.

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 any of the four parameters (template_path, records, out_dir, mask_pii). It mentions 'template' and 'records' in context but adds no semantic detail 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 clearly states it generates output per record from a template using a proprietary 'OWN byte-preserving fill engine'. The verb 'generate' and resource 'template' are specific, but the output type is not explicitly stated, though context from sibling tools suggests document outputs.

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 siblings like fill_form, plan_template_completion, or verify_fill. No mention of prerequisites or typical use cases.

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. It only mentions 'delegate' and creating a new file, but does not disclose side effects (e.g., whether the original file is modified), error conditions, or required permissions.

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, front-loaded with the core action. Every word earns its place, and the parenthetical '(delegate)' adds key context without extra verbiage.

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 (not shown), the description omits critical context: whether the merge overwrites if 'out_path' exists, whether the original file is unchanged, and what 'delegate' entails. For a tool with 4 required params and a potentially destructive operation, this is insufficient.

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 only gives an example for 'cell_range' (A1:B2) and mentions 'path' and 'out_path' implicitly, but does not explain 'table_index' or the meaning of 'delegate'. The schema itself provides no parameter 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 clearly states the action ('merge a table cell range') and the output ('write a NEW file'), providing a specific verb and resource. It stands out from siblings like 'split_merged_cell' by emphasizing the file creation aspect.

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. Siblings like 'set_cell_shading' or 'split_merged_cell' exist, but the description does not explain when merging is appropriate or mention any 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?

With no annotations, the description fully discloses behavioral traits: it leaves the window open, saves and closes nothing, and cold start can take tens of seconds. It also explains timeout 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 reasonably concise and front-loaded with the main action. It includes necessary details without being overly verbose, though it could be slightly more streamlined.

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 provides key context such as workflow, cold start, and timeout handling. With an output schema present, return value explanation is less critical. Some details about parameters are missing, but overall it is fairly complete for the tool's complexity.

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

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

The description explains the timeout_seconds parameter and its effect (isolated worker, unknown outcome), but does not explain the path or visible parameters beyond implying file type. Given 0% schema coverage, more parameter details would be beneficial.

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 opens a .hwp/.hwpx file in a controllable Hangul window. It distinguishes itself by mentioning that hand-opened windows are not safe anchors and that this tool should be used first for attaching by exact path.

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 explicitly states when to use the tool: to attach by exact path before using apply_to_open_hwp or apply_small_live_label_cells. It also mentions cold start delays and timeout behavior, although it does not explicitly state when not to use the tool.

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

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

With no annotations, the description carries the full burden. It discloses that the tool plans edits and does not mutate the open Hangul window ('The completed copy does not mutate the already-open same Hangul window — open it afterward'). It also specifies structural addressing. Slightly missing details on error behavior, but overall 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 front-loaded with the main action but includes multiple clauses and instructions that could be condensed. It is functional but not maximally concise, e.g., the sentence about named fields could be shorter.

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 complexity and the presence of an output schema, the description provides workflow context (gather values first, use complete_addressed_template) and clarifies structural addressing. It lacks detail on the compact parameter, but overall is sufficiently complete for planning.

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 explain parameters. It mentions 'file mode' but does not describe the 'path' parameter (file path) or the 'compact' boolean parameter. This leaves the agent guessing about their meaning and impact.

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 plans whole-template completion in file mode and returns addressable edit targets. It uses specific verbs ('plan', 'return') and distinguishes from siblings like 'complete_addressed_template' by specifying the workflow.

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 explicitly guides when to use this tool: 'start in file mode instead of mixing live field writes' and 'Gather ALL values first, then hand one complete addressed edits array to complete_addressed_template'. It also forbids replacing repeated text without explicit scope, providing clear do's and don'ts.

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?

Discloses that the tool does not mutate the open Hangul window, returns a session for later application, and explains behavior of edits (no named fields, structural addresses, no global replace). No annotations exist, so description covers the burden fully.

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 dense paragraph with multiple instructions. While it front-loads the main action, it could be more concise and better structured (e.g., bullet points) given the volume of detail.

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?

Covers use cases, behavioral constraints, integration with apply_addressed_edits, and mentions output session. With an output schema present, return values need not be explained. Leaves minor ambiguity about session_id but is largely 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?

Though top-level parameters lack descriptions (0% coverage per context), the description adds semantic value by explaining how to structure edits (no named fields, use structural addresses) and providing target format examples. This supplements the schema's nested 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 clearly states it resolves structural addressed edits in file mode without writing output, distinguishing it from the sibling tool apply_addressed_edits that writes later. It specifies the purpose as previewing to confirm edits resolve to intended targets.

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 explicit when-to-use guidance: use for whole-template completion, gather values first, start in file mode, preview before applying. Also warns against mixing live field writes and falling back, and names the alternative apply_addressed_edits for writing.

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 cover behavioral traits. It states no files are written, indicating read-only behavior, but lacks details on side effects, error handling, or what happens on validation failure.

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, clear sentence with no unnecessary words. It is front-loaded and compact, effectively communicating the core 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?

The description fails to explain the concept of 'three deterministic assessment variants' or what the output schema contains. For a tool with no annotations and an output schema, more context about return values and variant behavior is needed.

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 to the parameters. It does not explain 'spec' (an object with additional properties) or 'template_path' (a string), leaving the agent without context for correct parameter usage.

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 validates and previews three deterministic assessment variants without writing files. It uses specific verbs and resources, and distinguishes from siblings like 'apply_assessment' by emphasizing the non-write preview nature.

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

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

The description implies usage for preview before actual application, and the 'without writing files' constraint guides when to use it. However, it does not explicitly state when not to use it or mention alternatives like 'apply_assessment'.

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 provided, but the description explicitly states 'without writing output', clearly indicating a non-destructive preview operation. Additional behavioral details (e.g., output format) are not included but are covered by the output schema.

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

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

Single, concise sentence that effectively communicates the tool's purpose without extraneous 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's simplicity and the presence of an output schema, the description adequately covers the preview nature. However, no prerequisites or constraints are mentioned.

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?

Description adds context that replacements are find->replace pairs and path is the document path, but with 0% schema coverage, more detailed parameter descriptions would be helpful.

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 clearly states the tool previews multiple find->replace pairs as one edit session without writing output, distinguishing it from sibling tools like batch_replace and preview_search_and_replace.

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

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

The description implies usage for previewing batch changes before execution but does not explicitly state when to use it versus alternatives or document 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?

Without annotations, the description fully discloses behavioral traits: it creates a new file (never touching the original), returns a preview_token, and requires .hwpx format. It also explains the effect of each route and the outcome for unsupported .hwp files. This provides complete transparency beyond what the schema offers.

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. It starts with the core purpose, then breaks into two clearly separated usage paths, mentions the error case, and ends with the success result. Every sentence adds necessary detail without redundancy, achieving high density of useful information.

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

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

Given the presence of an output schema (not shown but indicated), the description does not need to detail return values. It covers the preview workflow, parameter constraints, error conditions, and the overall process (new file, untouched original). This provides a complete understanding for a preview tool with moderate complexity.

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

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

The description adds significant meaning to key parameters (`values`, `edits`, `output_path`) by explaining their purpose, constraints (mutual exclusivity), and behavior (e.g., new file creation). However, it does not mention `mode` or `candidate_id`. Given the 0% schema coverage, the description compensates well for the most critical parameters but omits two.

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 action ('Preview... pathlessly without writing it'), specifies the two routes (values vs. edits) with a clear distinction, and contrasts with likely siblings like apply_to_current_hwp_document by mentioning it returns a preview_token for later application. The verb 'Preview' is specific and accurately describes the output.

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

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

The description explicitly instructs to use either `values` or `edits`, never both, and explains the complete_and_load route. It also specifies that .hwp files are not supported. However, it does not directly compare against sibling preview tools (e.g., preview_addressed_edits) or state when to use this tool over them. The guidance is clear for the two main parameters but lacks broader context against 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?

With no annotations, the description must disclose behavioral traits. It states 'without writing output' but does not explain what the preview returns (e.g., count, list of changes) or whether an edit session is created. The lack of detail on side effects and output structure is a gap.

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 short sentence that efficiently conveys the core purpose. It front-loads the key information. However, it is slightly too brief given the lack of parameter details.

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 complexity (3 params, no schema descriptions, output schema exists but not detailed), the description is adequate but incomplete. It covers the main idea but omits parameter semantics and output details. The existence of an output schema reduces the need to explain return values, but behavioral context is still lacking.

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 should add meaning to parameters. It does not describe any parameters at all. While names like path, find, replace are somewhat self-explanatory, no additional context (e.g., path format, regex support, case sensitivity) 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 clearly states the tool's purpose: previewing a text replace as an edit session without writing output. It distinguishes from sibling tools like search_and_replace (which writes output) and preview_batch_replace. However, it could be more explicit about what the preview returns.

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

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

The description implies usage when the agent wants to see the impact of a replace before committing, but it does not explicitly mention alternatives or when not to use this tool. No guidance on when to prefer this over search_and_replace or preview_batch_replace.

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 discloses that the tool requires no COM or ROT access, is a pure preview without probing or attaching candidates, and defers attachment. This provides good behavioral context, though it does not detail the output or potential side effects beyond being a preview.

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 four sentences, front-loaded with the primary purpose, and each sentence adds distinct value (behavior, alternatives, constraints). No redundant or unnecessary text.

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?

While the description covers purpose, usage, and behavioral transparency well for a preview tool, it omits parameter guidance and does not hint at the output structure (though output schema exists). Given the complexity of the input (3 params, nested object) and low schema coverage, the description should provide more parameter context to be 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 description must compensate. It does not explain the required parameters 'path' and 'values' (an object of key-value pairs) or the optional 'timeout_seconds'. The description only discusses tool behavior, leaving parameter semantics entirely to the schema with no added context.

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 starts with a specific verb and resource: 'Preview small live label:value cell fills' and explicitly distinguishes from whole-template completion and sibling tools like complete_addressed_template and apply_small_live_label_cells. The purpose is immediately 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 explicit when-to-use and when-not-to-use guidance: it contrasts with full template completion, recommends complete_addressed_template for structured forms, and notes that exact-path attachment is deferred to apply_small_live_label_cells. Alternatives are named.

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 but only mentions technical stack (python-hwpx, Playwright/Chromium). It fails to disclose behavioral traits like read-only nature, prerequisites, 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 single sentence is concise and front-loaded, but it lacks critical details. It earns its place but could be more informative without significant length increase.

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, return values are covered, but the description fails to explain parameter meanings and behavioral context, leaving the tool poorly specified for an agent.

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 provides no information about any of the 5 parameters. The agent must rely solely on parameter names, which is insufficient for correct usage.

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 renders page PNG previews using python-hwpx and Playwright/Chromium. However, it does not differentiate from other preview tools among siblings, such as preview_addressed_edits, which could cause confusion for an AI agent.

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 other preview or rendering tools. The description lacks context for when to prefer this over 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?

With no annotations, the description carries the full burden. It clearly states the tool is side-effect-free, never writes, and never auto-selects, and explains its handling of unsupported/unsaved/unprovable documents. However, it does not detail potential 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 two sentences long, front-loaded with the core purpose, and every sentence adds unique value about behavior and limitations.

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 no parameters and an output schema exists, the description sufficiently covers its purpose, side-effect-free nature, and handling of edge cases. It could mention expected output format, but the output schema fulfills that.

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?

There are no parameters, so schema coverage is 100%. According to guidelines, 0 parameters yields a baseline of 4, which is appropriate since the description does not need to add parameter info.

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 it resolves the current document inventory without writing, making the verb-resource relationship clear. It distinguishes itself from sibling tools that modify the document by emphasizing side-effect-free behavior.

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 this tool is for getting document info without side effects, but it does not explicitly state when to use it versus similar tools like preview_current_hwp_document, nor does it provide 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?

With no annotations, description carries full burden. It discloses that the tool performs a restore/undo operation, but lacks details on side effects, permissions, or what happens to current state beyond restoration.

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?

Single, front-loaded sentence with no extraneous information. Every phrase 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?

Has output schema so return values are covered, but missing parameter description and limited behavioral context leaves gaps for a tool with one required parameter.

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 description does not mention journal_path or explain its meaning. The parameter's purpose must be inferred from the tool name and description, which is insufficient.

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 clearly states 'Restore the pre-apply snapshot of an applied edit session' with parenthetical 'file-mode undo', specifying the verb and resource well. Distinguishes from siblings like apply_edit_session.

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

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

No explicit when-to-use or alternatives guidance. The phrase 'file-mode undo' implies usage after applying an edit session, but does not exclude other scenarios or compare to sibling tools.

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

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

Describes returning masked findings but does not explain masking behavior, pattern coverage, or whether it modifies the document. No annotations to supplement.

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?

Single sentence is concise, but lacks necessary detail for the parameter and behavioral context. Could be more informative without losing brevity.

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

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

With one parameter and an output schema (unseen), the description should clarify the input and output format. It mentions 'masked findings' but does not describe the structure. Incomplete for a scanning tool.

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

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

Schema coverage is 0% (no description for 'path'). The description does not explain what 'path' refers to (file path, document ID, extracted text location).

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 action (scan), resource (extracted document text), and specific patterns (Korean PII). It distinguishes from siblings like extract_text and find_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?

No guidance on when to use or avoid this tool. No prerequisites mentioned, such as needing pre-extracted text.

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