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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Accept all tracked changes' implies a mutation, but it does not disclose whether changes are irreversible, whether the document must be saved afterward, or what impact it has on comments or other artifacts. This is a significant gap for a destructive operation.

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

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

The description is extremely concise, consisting of four words with no redundancy. Every term is necessary, and the action-target structure is front-loaded. It does not waste space, though it could be expanded with additional 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 single-parameter tool, the description could be more complete. It fails to mention whether the operation returns a success indicator, how errors are handled, or any prerequisites (e.g., open document). Given no output schema and no annotations, the description leaves critical execution details unspecified.

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

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

The schema description coverage is 100%—docId is described as 'Document ID'. The tool description adds no additional meaning to this parameter; it only restates the resource being acted upon. Since the schema already minimally describes the parameter, a baseline of 3 applies.

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

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

The description clearly states the action ('Accept') and the resource ('all tracked changes'), which directly conveys the tool's purpose. It distinguishes implicitly from other docx tools (e.g., docx.comments_delete, docx.replace_text), though it does not name an alternative or scope beyond accepting all changes.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that accepting changes is a non-reversible operation, nor does it reference any related tools like docx.comments_list or docx.save. The agent receives no contextual cue about when accepting all changes is appropriate.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It does not state whether closing saves changes, invalidates the docId, releases resources, or is idempotent. This is a substantial gap for a state-changing operation.

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

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

The description is extremely concise and front-loaded, containing no filler words. It is appropriately short, though it could use a little more behavioral detail without losing its 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?

For a single-parameter tool with no output schema and no annotations, the description is too thin. Critical context is missing, especially whether close saves or discards changes and what happens to the document handle afterward.

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

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

Schema description coverage is 100%, and docId is already described as 'Document ID.' The description adds no additional parameter semantics, so the baseline 3 applies.

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

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

The description uses a specific verb and resource: 'Close a DOCX document.' It clearly identifies the operation and object type, and it is naturally distinguishable from siblings like open and save. However, it does not explicitly differentiate itself from related tools, so it does not reach a 5.

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

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

There is no guidance about when to call this tool versus alternatives such as docx.save or docx.open. It only states the action itself, leaving the agent to infer that it should be used after finishing work on a document.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It only states 'Add a comment' without mentioning that this mutates the document, indicates whether it returns a value, or describes any error conditions. This is a critical omission for a modification operation.

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

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

The description is very short, but this is under-specification rather than effective conciseness. It lacks essential operational details and does not use its brevity to provide value; the single sentence offers no information beyond what the tool name already implies.

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

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

The description is severely incomplete for a mutating tool. It does not disclose that the operation modifies the document, whether the document must be open, or what the return value is. An agent receive no indication of side effects, preconditions, or postconditions, making it inadequate even for a simple operation.

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

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

The input schema already provides descriptions for all three parameters (text, docId, author) with 100% coverage. The description adds no additional parameter information, so it does not enhance the schema. The baseline of 3 applies due to the high schema description coverage.

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

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

The description clearly states the verb 'add' and the resource 'comment', making it evident the tool performs an addition operation on comments. It is distinguishable from sibling operations like comments_list and comments_delete. However, it lacks any context about where the comment is added or any prerequisites, so it only barely exceeds a restatement of the tool name.

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

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

The description provides no guidance on when to use this tool, when not to use it, or which alternatives exist. It does not mention any prerequisites such as the document being open or saved, nor does it reference the sibling comment tools.

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

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

With no annotations at all, the description carries full burden for behavioral disclosure. It only says 'Delete a comment,' which implies a destructive action but omits any side effects (permanence, whether the document must be open, whether it can be undone, etc.). Minimal value beyond what the verb implies.

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 short (4 words), which is concise, but the brevity comes at the cost of necessary information. It's front-loaded with the action, but there's no structure to guide the agent. Moderate score for clarity at the expense of substance.

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

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

For a destructive operation with no annotationscars, no output schema, no parameter descriptions, and zero schema coverage, the description is severely incomplete. It doesn't explain what the comment ID is, whether deletion is permanent, or any prerequisites. An agent would struggle to invoke this correctly without additional context.

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

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

The input schema has 0% description coverage, and the description adds nothing about what docId or id mean, their format, or how they relate to each other. The agent must guess that docId identifies the document and id identifies the comment, but even that is not stated. The description fails to compensate 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 states a specific verb ('Delete') and resource ('comment'), which is clear enough to understand the primary action. It distinguishes it from sibling tools like comments_add and comments_list, though it doesn't explicitly contrast with them. The core purpose is unambiguous.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of contexts where deletion is appropriate, prerequisites, or scenarios where comments_add or comments_list might be more suitable. The agent gets zero routing information.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'List comments' implies a read-only operation but does not describe the return format, scope, ordering, or whether any side effects occur. The description adds almost no behavioral detail beyond the operation name.

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

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

The description is extremely concise and front-loaded, with no wasted words. However, it is so terse that it borders on under-specification, providing little more than the tool name itself and omitting useful 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?

For a simple single-parameter listing tool, 'List comments' is minimally adequate. However, with no output schema and no behavioral detail, the description does not fully inform the agent about what the returned comments look like or what exactly is listed.

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

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

Schema description coverage is 100%: docId is documented as 'Document ID'. The description adds no parameter-level meaning, but the schema already fully accounts for the single parameter, so the baseline of 3 is appropriate.

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

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

The description states a specific verb ('List') and resource ('comments'), clearly identifying the operation. It is understandable on its own, though it does not explicitly differentiate itself from sibling tools like comments_add or comments_delete beyond the obvious contrast.

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

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

No guidance is provided about when to use this tool versus alternatives such as comments_add or comments_delete. The description does not mention context, prerequisites, or exclusions, leaving the agent to infer 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 must carry the full burden of behavioral disclosure. It states the action but does not address critical behaviors such as whether the target file is overwritten if it exists, whether the original document remains open, or which document becomes the active one after copying. The phrase 'and open it' hints at a modal change but does not explain implications for the session. This under-specification is a significant 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, well-formed sentence with no redundancy. The action is front-loaded and every word is necessary. It is concise without sacrificing clarity, achieving maximum 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?

The tool has no annotations, no output schema, and only two parameters, yet the description still lacks essential context for correct invocation. It does not explain what 'open' means in the tool ecosystem (e.g., becomes the active document), what happens to the existing open document, or what the tool returns (if anything). An agent could make incorrect assumptions about side effects and return values, making the description incomplete 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?

Schema description coverage is 100%, so both parameters (sourceDocId and targetPath) are already documented in the input schema. The description adds no additional semantic value, such as examples or validation rules. The baseline of 3 is appropriate because the schema already handles parameter documentation.

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

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

The description states a precise action: copy a document to a new file and open it. The verb 'copy' is specific, the resource is clear (document), and the outcome includes opening the new file. This clearly distinguishes it from sibling tools like docx.open (which only opens) and docx.save (which saves), so there is no ambiguity.

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

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

The description implies usage (copying a document) but does not explicitly state when to choose this over alternatives like docx.open or docx.save. It does not mention exclusions or provide routing guidance, leaving the agent to infer from the context. This is adequate but lacks proactive differentiation.

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 only says 'Find text' and gives no context about whether the operation is read-only, what the search returns, whether it supports case sensitivity, or how it handles multiple matches. This is insufficient for an agent to predict the tool's behavior beyond the name.

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 short and front-loaded, but it is under-specified rather than concise. A single sentence that does not explain the tool's behavior or parameters does not earn its place as an adequate description for a tool with three parameters and a potentially ambiguous return value.

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

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

There is no output schema, no annotations, and no description of return value, edge cases, or relationship to sibling tools. Given that there is a sibling called text_find_locations, the description is incomplete without explaining how this tool differs. An agent cannot confidently call this tool correctly.

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

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

The schema describes docId and query, and the mode parameter has an enum but no description. The description adds no extra meaning to any parameter—it merely restates the concept of searching. With 67% schema coverage, there is partial coverage, but the description fails to clarify how mode works or what query syntax is expected.

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

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

The description states a specific verb ('find') and resource ('text in document'), giving a basic sense of the operation. However, it is vague about what 'find' actually returns (matches, locations, counts?) and does not distinguish itself from sibling tools like docx.text_find_locations or docx.get_text. The purpose is clear in general but not precise enough to guide an 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?

The description provides no guidance on when to use this tool versus alternatives. It does not mention docx.text_find_locations or docx.get_text, nor any conditions that would select this tool over them. An agent is left to infer usage entirely.

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

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

With no annotations, the description carries the behavioral burden. The word 'Find' plus 'for MANUAL analysis' implies a non-mutating lookup operation, but the description never explicitly states that the document is not modified. It also does not clarify what qualifies as an 'empty row' or whether the result includes row indices, cell contents, or everything.

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

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

The description is a single concise sentence with no filler. It front-loads the core action and adds a clarifying purpose, making it appropriately sized for a simple read-only tool.

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

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

The tool has only one parameter, no output schema, and a straightforward purpose. The description is essentially enough for an agent to decide whether to call it. Minor gaps include not describing the return shape or the specific definition of an empty row, but these are acceptable for such a simple operation.

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

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

Schema description coverage is 100% and the only parameter, docId, is already described as 'Document ID.' The description adds no additional parameter-specific behavior, so the baseline of 3 applies.

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

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

The description clearly states a specific verb and resource: 'Find all empty rows in tables.' This is distinct from sibling tools like docx.get_table_content or docx.table_edit, so an agent can tell it apart without needing to inspect each sibling's schema.

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

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

The phrase 'for MANUAL analysis' gives an implied use case: the agent should surface results for human review rather than automatically modifying. However, it does not explicitly say when not to use this tool or which alternative to choose for deletion/editing, such as docx.remove_table_row or docx.table_edit.

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

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

There are no annotations, so the description carries the full disclosure burden. It implies mutation with 'Fix' and adds a caution, but it does not state that the document is being modified, whether the change is persisted, whether it can be undone, or what side effects the action has on the docx state.

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

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

The description is compact, specific, and front-loaded with the action and the important manual-check condition. There is no redundant detail or repetition of schema contents.

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

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

The tool is a simple setter with a complete input schema, but the operation mutates document state and the description does not explain persistence or side effects. With no annotations and no output schema, important behavioral context is missing for an AI agent deciding how to invoke this tool safely.

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

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

Schema coverage is 100%, so the input schema already documents docId, paragraphIndex, and setLTR and even explains that true means LTR and false means RTL. The description adds no additional parameter-level meaning, so the schema baseline of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Fix RTL direction of paragraph.' It tells an agent what the tool does and differentiates it from other document tools because no sibling tool addresses RTL paragraph direction. The added 'USE ONLY after manual check' further tightens its purpose.

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

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

The instruction 'USE ONLY after manual check' provides a clear usage gate: the tool should not be invoked until a human has verified the paragraph direction. It does not explicitly name alternatives or say when not to use it, but the conditional is strong and actionable.

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 available, so the description carries the full burden of behavioral disclosure. It does reveal part of the return contract ('all rows with text and empty status'), which hints at how missing text is handled, but it stops short of explaining failure modes for invalid tableIndex, performance characteristics, or whether anything is mutated. It's honest and non-contradictory, but noticeably terse for a tool with zero annotation support.

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

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

The description is economical, front-loading the action ('Get content of specific table') and following up with a dash-separated clarification of the return shape. Every phrase earns its place without an excess word; 'specific' is mildly redundant, but the overall structure is clean and scannable for an agent parsing it at a glance.

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 this is a simple getter with no annotations, no output schema, and only two string/number params, the description does a decent job communicating the return value format. However, it leaves gaps that would be valuable for an agent invoking it blind — most notably, there's no hint about where the tableIndex comes from, and the phrase 'empty status' could mean either the status of empty cells or whether the row itself is empty. These aren't fatal flaws, but they make the tool slightly under-explained for an agent that must call it correctly.

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

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

Schema coverage is 100% — both docId and tableIndex have descriptions in the input schema (e.g., 'Table index (0-based)'), which is the appropriate baseline for this dimension. The tool description adds nothing beyond the schema: it mentions 'specific table' without referencing the index parameter or providing example values or constraints. So 3 is correct, since the schema does the heavy lifting and the description neither helps nor hurts.

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

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

The description uses a specific verb and resource: 'Get content of specific table', and the dash clause explains the response shape ('all rows with text and empty status'). It is unambiguous about its scope, distinguishing itself from sibling table-related tools like docx.tables_list by focusing on per-row content retrieval. However, it doesn't explicitly compare itself to siblings such as docx.get_text or docx.find_empty_table_rows, even though the output hint provides some 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?

Usage is implied by the imperative 'Get content of specific table' — an agent can reasonably infer when to call it, and the output clarification suggests the kind of data to expect. Yet there is no explicit statement about when to prefer it over alternatives (e.g., docx.tables_list or docx.find_empty_table_rows) or any exclusions/prerequisites. This lands at 'implied usage' without crossing into actual guidance.

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

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

With no annotations, the description carries the full burden, but 'Extract all text' reveals no behavioral traits beyond the action itself. It does not disclose whether the operation is read-only, what format the extracted text takes, whether headers/footers are included by default, or any 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 extremely short—three words—but this is under-specification rather than effective conciseness. It front-loads nothing useful and omits essential context that an agent would need.

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

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

For a tool with two parameters, no output schema, and no annotations, the description is grossly incomplete. It does not explain return value, parameter semantics, scope behavior, prerequisites, or any edge cases, making it insufficient for reliable invocation.

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

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

Schema coverage is 50%: docId has only the minimal 'Document ID' description and scope has none. The description adds no parameter meaning—it doesn't explain what 'document' vs 'headers' vs 'footers' vs 'all' scopes mean or how to obtain a docId. Since the description fails to compensate for the partial schema coverage, this is a clear 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 a specific verb and resource ('Extract all text'), but 'all text' is ambiguous—it doesn't clarify whether this means only the main document body or includes headers, footers, tables, etc. The scope parameter hints at this, but the description itself does not distinguish the tool from siblings like docx.get_table_content or docx.read_paragraph_range.

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. The description does not mention prerequisites (e.g., whether the document must be open), nor does it name any sibling tool that should be used instead for specific extraction needs.

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 behavioral burden. 'List' implies a read-only operation, which is clear enough at a basic level. However, the description does not disclose what exactly the list contains (e.g., names, paths, content snippets) or how the result is structured.

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

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

The description is a single, focused sentence with no wasted words. It fully front-loads the core purpose and avoids any redundant phrasing.

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

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

The tool is simple with one parameter and no nested objects, so the description is mostly sufficient. However, with no output schema and no return-value note, an agent must infer what 'list headers and footers' returns. Slightly more detail would make this 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 100%, so the description does not need to explain parameters. The sole parameter docId is adequately documented in the schema as 'Document ID'. The description adds no extra parameter nuance, which is fine given the full schema coverage.

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

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

The description states a specific verb and resource: 'List headers and footers'. This clearly identifies the tool's operation and distinguishes it from sibling list tools like docx.images_list and docx.comments_list.

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

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

No guidance is provided about when to use this tool versus alternatives. There are no exclusions, prerequisites, or preferred conditions stated, leaving the agent to infer usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action without elaborating on behavior — e.g., whether this returns image URLs, relationship IDs, alt-text, or positions, whether it includes images in headers/footers or text boxes, and whether it is side-effect-free. For a read operation with zero annotation coverage, more context is needed about what 'all images' means in practice.

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

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

Three words, front-loaded, zero fluff. Every word earns its place. It loses one point because the extreme brevity forgoes an opportunity to clarify return format or scope, potentially making the conciseness more under-specified than elegant.

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

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

For a one-parameter tool with no output schema, the missing piece is what the returned list contains. The agent knows the input (docId) but cannot predict whether the output is an array of strings, objects with metadata, or references. Given no output schema exists, the description should compensate by hinting at the return shape or scope, which it doesn't. That said, for such a simple tool, the information need is relatively low.

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

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

The schema description coverage is 100% (docId is documented as 'Document ID'), so per the baseline rule, a 3 is appropriate. The description adds no parameter-specific information, but none is strictly required since the sole parameter is fully documented in the schema. With 1 required param and no enums or nested objects, there's little complexity for the description to clarify.

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 'List all images' uses a specific verb ('List') and resource ('images'), clearly identifying the operation. It stands apart from siblings like docx.get_text or docx.tables_list since 'images' is a distinct resource. However, it doesn't explicitly state the scope (e.g., document-wide, including headers/footers) or what exactly is listed (file names, inline shapes, both), which keeps it from a 5.

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

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

No guidance is given on when to use this tool instead of alternatives, such as docx.list_parts or docx.find, which might also surface image-related references. The name implies a read-only listing operation, but there's no explicit statement of when this is the right choice versus a sibling. An agent would have to infer usage from the name and schema 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 provided, the description carries the full burden of behavioral disclosure. It only says 'List', implying a read operation, but does not explain what information is returned, whether the document must be open, or whether this includes relationship parts, content types, or only main document parts.

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 with no wasted words, which is concise. However, it is under-specified and lacks any structural elements like examples or expected output, so it does not fully earn its place as a useful definition.

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

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

Given no output schema and no annotations, the description should provide more context about what 'parts' means and what the tool returns. An agent would have to infer behavior from sibling tool names like part_read and part_write, which is not sufficient for confident invocation.

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

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

Schema description coverage is 100% for the single parameter, and the schema already describes docId as 'Document ID'. The description adds no additional meaning about the parameter, so the baseline of 3 applies.

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

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

The description states a verb and resource ('List document parts'), so it is not a pure tautology, but 'parts' is left undefined and could mean internal OPC package parts, sections, or other components. It does not distinguish itself from sibling tools like part_read or part_write.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention related tools such as docx.part_read, docx.part_write, or docx.metadata_get, nor does it state any prerequisites like the document needing to be open.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only operation, but the description does not state what metadata is returned, whether the operation has side effects, or what errors or prerequisites apply.

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

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

The description is a single short sentence with no redundancy and the action is front-loaded. However, it is under-specified rather than usefully concise, providing no extra context beyond the tool name itself.

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

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

For a tool with no output schema and no annotations, the description should explain what metadata is returned and any operational context. It does neither, leaving an agent to guess at the return format and behavior beyond the basic 'get metadata' intent.

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

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

Schema description coverage is 100%, and the single parameter docId is already described as 'Document ID'. The description adds no additional meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('document metadata'), which clearly indicates the tool's function. It is distinct from content-focused siblings like docx.get_text or docx.styles_get, though it does not explicitly name or contrast those alternatives.

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

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

No guidance is provided about when to use this tool versus other metadata-adjacent or read-only siblings. There is no mention of prerequisites, such as the document needing to be open, or any exclusions that would help an agent choose this tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get numbering' implies a read operation but does not state what is returned, whether it has side effects, or what the output looks like.

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 short and front-loaded, but this is under-specification rather than effective conciseness. It does not provide enough information to be useful on its own.

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

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

For a tool with no output schema and no annotations, the description should explain what 'numbering' means and what the caller receives. It does neither, leaving the tool functionally opaque despite having only one 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 description coverage is 100% and the single parameter docId is described as 'Document ID'. The description adds no additional parameter meaning, but the schema already covers the only parameter adequately.

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

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

The description states a verb and resource ('Get numbering'), so it is not a pure tautology, but it is vague about what 'numbering' refers to in a DOCX context. It does not distinguish itself from the sibling numbering_set beyond the get/set naming convention.

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

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

There is no guidance on when to use this tool versus alternatives such as numbering_set or other document inspection tools. The intended use case must be inferred entirely from the tool name.

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 explain behavioral effects. It only says 'Set numbering' without stating whether it modifies the document in place, what format the XML should follow, or what the return value is. The lack of detail means the agent cannot anticipate side effects or expected outcomes.

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 brief (two words), which is concise but not adequately informative. While it is front-loaded, the lack of essential details makes it under-specified, so the brevity is not a virtue here.

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 numbering in docx (definitions, formatting, references), the description is entirely incomplete. It does not explain the purpose of the operation, how to construct the XML, what error conditions exist, or what happens on success. Without this context, the agent cannot reliably use the tool.

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

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

The schema provides descriptions for both parameters ('Document ID' and 'XML content'), but these are minimal and uninformative. The tool description adds no further context about the XML structure, allowed values, or the relationship between docId and the numbering operation, leaving the agent with insufficient understanding of how to provide valid input.

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 'Set numbering' provides a verb and a resource, but the resource 'numbering' is ambiguous—it could refer to list numbering, page numbering, or other numbering definitions in a docx context. It does not clearly distinguish this setter from other setters like part_write or replace_text, and fails to specify the scope or effect.

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

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

No guidance is given on when to use this tool versus alternatives such as numbering_get or other setter operations. There is no mention of prerequisites, context, or typical use cases, leaving the agent without direction for selecting this 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'open' and gives no indication of side effects, session state, file modification, locking, or errors. An agent cannot anticipate what happens after the call.

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

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

The description is a single, no-waste sentence with no redundant content. It is very brief, though some may argue it is too sparse to be truly useful; structurally it is clean and front-loaded.

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

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

For a tool with two optional-looking parameters, no output schema, and many sibling operations, this description is insufficient. It does not explain when to call it, what inputs to prefer, what a successful open returns, or what subsequent operations become available.

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

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

Schema coverage is 100%, and both parameters have clear inline descriptions in the schema. The tool description adds nothing about how path and bufferBase64 relate (e.g., mutually exclusive, precedence, or which to prefer), but the schema already carries the required informational weight.

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 is essentially a restatement of the tool name: 'Open a DOCX document' says little beyond docx.open. It gives no detail about what opening means, what state changes occur, or how this differs from sibling tools like docx.copy or docx.save.

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

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

There is no guidance on when to use docx.open versus the many sibling tools. It does not say whether docx.open is a prerequisite, whether it loads a document for editing, or whether alternatives like docx.copy should be used instead in certain scenarios.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only restates the action implied by the tool name and does not reveal what the read returns, whether raw XML is decoded, whether binary parts are handled, or whether the document must be open.

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

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

The description is brief and front-loaded, containing no wasted words. However, it is so sparse that it sacrifices useful guidance in favor of 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 no output schema and zero annotation support, the description should provide enough context about what a caller can expect from the returned data. It does not explain the return value, behavior with invalid part paths, or how this low-level read relates to the many sibling tools.

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

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

Schema description coverage is 100%, so the docId and partPath parameters are already documented. The description adds no deeper meaning about path formatting, accepted part types, or side effects beyond what the schema provides.

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

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

The description states a specific verb ('Read') and resource ('a document part'), making the basic action clear. It is distinct from siblings like part_write and list_parts, though it does not explicitly contrast itself with higher-level reading tools like get_text.

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

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

The description gives no guidance on when to use part_read versus alternatives such as list_parts, get_text, or metadata_get. There is no stated context, prerequisites, or exclusion criteria.

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

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

With no annotations to fall back on, the description must disclose side effects, permissions, or failure modes. It states only 'Write a document part' and gives no information about consequences, requirements, or error handling. The agent is left without any insight into what happens when the part is written.

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 appropriately concise and front-loaded. However, it is so minimal that it borders on being uninformative. Still, for conciseness alone, it earns a high score as there is no verbosity to critique.

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

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

The description is incomplete even given the lack of output schema and annotations. It does not explain the purpose of writing a part, the relationship to the document, potential effects on other parts, or any expected outcomes. The agent has insufficient information to use the tool correctly.

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

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

The schema descriptions cover 100% of parameters, each with a basic label ('XML content', 'Document ID', 'Part path'). The tool description adds nothing beyond these labels, so the baseline of 3 applies. The parameter meanings are minimally clear from the schema, but no additional context 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 states a verb ('Write') and a resource ('document part') but is extremely vague. It does not specify what a 'document part' is, what writing entails, or how it differs from sibling tools like docx.part_read. The wording is essentially a restatement of the tool name.

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

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

There is no guidance on when to use this tool versus alternatives. No mention of typical scenarios or distinctions from related tools (e.g., docx.part_read, docx.metadata_get). The description provides no context for selection.

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

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

With no annotations, the description carries the full burden. It only says the tool reads paragraphs with formatting info, but does not disclose whether it is read-only (though implied), what happens on out-of-range indices, error behavior, or return format. For a read operation with no annotation safety coverage, this is a significant 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?

A single, well-formatted sentence that immediately states the action and key value (formatting info) upfront. There is no wasted verbiage, and the structure is efficient and scannable.

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

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

For a read tool with three required parameters and no output schema, the description is adequate to understand its purpose but lacks details on return structure, edge cases, and prerequisites. Since annotations are absent, the full onus falls on the description, and it leaves some operational questions unanswered, particularly around what the returned data looks like.

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

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

Schema coverage is 100% (all three parameters have descriptions in the schema), so the baseline is 3. The description adds minimal value beyond the schema, just implying the range concept with 'range of paragraphs', but no additional semantic clarity on the parameters or their interplay.

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

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

The description states a specific verb ('Read'), resource ('paragraphs'), and scope ('range' with formatting info like RTL, style, alignment), making it distinct from plain-text reads like get_text. It is clear, but it does not explicitly name or differentiate from sibling tools, so it falls just short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. For instance, it doesn't mention that get_text should be used for plain text or that this is the tool for formatted extraction. There's no 'when not to use' or reference to siblings, leaving the selection to inference.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'by coordinates' implying index-based removal, but does not disclose side effects (e.g., whether changes persist without saving, effects on document structure, or error behavior for out-of-range indices). The cautious phrase hints at risk but lacks specifics.

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 fluff. The caution 'USE ONLY after manual analysis' is placed after the main action, but it is concise and the core purpose is front-loaded. It could be slightly more informative without losing conciseness, but it is efficient.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It does not explain the return value, whether the document must be saved afterward, how the tool handles missing rows, or the relationship to manual analysis. Given the sibling tools like docx.save, some context is implied, but the description alone leaves important operational details unspecified.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's mention of 'coordinates' aligns with the rowIndex and tableIndex parameters but adds no new detail beyond the schema's descriptions. It does not explain how indices are validated or what happens if invalid.

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 action clearly: 'Remove specific table row by coordinates' with a specific resource (table row) and method (by coordinates). It distinguishes from sibling tools like docx.table_edit which are broader, though it does not name them explicitly. The purpose is unambiguous.

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

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

The phrase 'USE ONLY after manual analysis' gives a caution but does not explain what analysis is needed or when to choose this tool over alternatives like docx.table_edit or docx.find_empty_table_rows. It lacks explicit when-to-use or when-not-to-use guidance relative to siblings.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only states 'replace' and gives no information about mutation effects, whether formatting is preserved, whether headers/footers are affected, or how the tool behaves with regex patterns.

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

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

The description is short and front-loaded, but it is under-specified rather than efficiently concise. One vague sentence does not earn its place when five parameters and two enums need contextual explanation.

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 five parameters, two enum fields, no output schema, and no annotations, this one-line description leaves major gaps: match behavior, regex semantics, where scope, all-occurrence behavior, and error conditions are all unaddressed. An agent would struggle to call this tool correctly without inspecting external documentation.

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

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

The input schema already describes docId, match, and replace, but the description adds no meaning for the undocumented mode and where parameters. It does not clarify defaults, the difference between literal and regex matching, or the effect of 'document', 'headers', 'footers', and 'all' scopes.

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 phrase 'Replace text in document' states a clear verb and resource, but it does not specify scope or behavior, such as whether replacement applies to all occurrences or only first matches. It also fails to distinguish this tool from sibling docx.text_run_replace, which is also a text-replacement operation.

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

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

No guidance is given about when to choose this tool over docx.text_run_replace, docx.find, or docx.text_find_locations. There is no mention of suitable contexts, prerequisites, or when the regex/literal modes should be used.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Save a DOCX document' without mentioning whether it overwrites existing files, what happens if 'path' is omitted, whether it persists to disk or memory, or what the tool returns (e.g., success status, base64 data). This is a significant gap for a mutating operation.

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

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

The description is a single, concise sentence with no filler or redundancy. It is efficiently front-loaded with the core action. While it is minimal, conciseness is not the issue; the lack of content is addressed under other dimensions.

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 that likely performs a side-effect (saving), the description is inadequate. It does not explain the return value (despite no output schema), behavior when 'path' is absent, or how 'returnBase64' affects the output. Given the absence of annotations and output schema, an agent cannot predict the tool's behavior with confidence, making the description 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 provides complete descriptions for all three parameters (path, docId, returnBase64), so the schema already covers semantics. The tool description adds no additional nuance, such as the relationship between path and returnBase64 or the meaning of docId in this context. Given 100% schema coverage, the baseline of 3 is appropriate; the description does not enhance parameter understanding.

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 'Save a DOCX document' clearly states the verb and resource, making the tool's core purpose unambiguous. It doesn't explicitly differentiate from siblings like docx.copy, but no sibling performs the same save action, so confusion is unlikely. However, it omits specifics about the destination or effect (e.g., to a file path, in memory).

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

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

No guidance is given on when to use this tool versus alternatives. While no direct sibling exists for saving, the description does not mention typical use cases (e.g., after modifications) or any prerequisites (e.g., that the document must be open). An agent must infer the context from the tool's name alone.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states 'Get SDT content', providing no information on return format, error handling, side effects, or even explicit confirmation that the operation is read-only. It adds no value beyond what the tool's name already implies.

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 in length but not in a useful way. It lacks necessary information such as the purpose of the identifiers or expected outcomes. It is under-specified rather than efficiently concise, and the sentence does not earn its place by adding context beyond the tool name.

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

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

Given the tool's low complexity (2 simple parameters, no output schema), a brief description might be acceptable, but this one is too bare. It does not explain what 'SDT content' means, how to specify the tagOrAlias, or what the agent should do with the result. An agent cannot fully determine call correctness or interpret responses from this description alone.

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

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

The input schema provides 100% description coverage for both parameters (docId: 'Document ID', tagOrAlias: 'SDT tag or alias'). The description adds no additional meaning or format details for these parameters, so the baseline of 3 applies because the schema already documents them adequately.

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 'Get SDT content' states a specific verb (get) and resource (SDT content), making the tool's purpose clear. The name 'docx.sdt_get' and the sibling 'docx.sdt_put' provide implicit distinction between reading and writing, though the description itself does not explicitly mention this differentiation.

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

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

There is no guidance on when to use this tool versus alternatives like docx.sdt_put or other read tools (e.g., docx.get_text). No mention of prerequisites (e.g., document must be open) or conditions for use. The description offers no context for choosing this tool over siblings.

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 supplied, the description bears full responsibility for behavioral disclosure. It only states 'Set SDT content' with no mention of side effects, required state (e.g., document must be open), error behavior, or reversibility. An agent is left completely uninformed about the consequences of invoking this mutation.

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 short (one phrase), which is technically concise, but it is under-specified to the point of being nearly useless. It does not front-load any crucial information beyond the bare action. The brevity is not effective because it omits essential 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?

This is a mutation tool with no annotations and no output schema, yet the description provides no context about SDT concepts, expected XML fragment format, or any operational requirements. It is entirely inadequate for an agent to correctly use this tool without external knowledge.

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 100% description coverage for all three parameters (docId, tagOrAlias, xmlFragment), so the schema already documents their meaning. The description adds no additional semantic value beyond the schema, which is acceptable per the baseline of 3 when schema coverage is high.

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

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

The description states a verb ('Set') and a resource ('SDT content'), which is slightly above a tautology since it clarifies the action, but it is extremely vague. It does not mention the document or the tag/alias, nor does it distinguish from sibling docx.sdt_get beyond the obvious get/set polarity. An agent would still need to guess what SDT content means in practice.

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 vs alternatives. There is no mention of prerequisites, such as an open document, or when one might prefer this over other document editing tools. The description offers zero context for selection.

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

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

With no annotations and no output schema, the description carries the full burden of explaining behavior, but it only says 'Get document styles.' It implies a read-only operation but does not disclose what is returned, whether defaults are included, side effects, 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 short, front-loaded single sentence with no wasted words. It is efficient, though the brevity comes at the cost of behavioral and usage 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 the tool has only one parameter, it has no output schema and no annotations, so the description should explain what the caller receives. It does not state the return shape or the scope of 'styles,' leaving an agent to guess at the expected result.

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

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

The input schema already fully documents docId with 100% coverage, so the description does not need to repeat it. The description adds no additional meaning or constraints beyond what the schema provides, which meets the baseline for fully covered parameters.

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

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

The description states a clear verb ('Get') and resource ('document styles'), and the name pairs naturally with docx.styles_set. However, it does not explicitly distinguish itself from other getters or say what 'styles' means in this context.

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

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

There is no guidance on when to use this tool versus siblings like docx.styles_set or docx.metadata_get. The intended use is only implied by the name and definition, with no explicit selection criteria or exclusions.

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

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

With no annotations, the description must disclose behavior, but it only says 'Set document styles.' It doesn't state whether existing styles are overwritten, merged, validated, or what errors might occur. The effect on the document and the response format are completely unaddressed.

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 brief and structurally clean, but it's so short that it omits essential information. While conciseness is good, here it sacrifices clarity, making it less useful than a slightly longer but more informative description.

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

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

There is no output schema, and the description does not mention return values, side effects, or preconditions. Given that the tool modifies a document, the lack of any context about the resulting state or potential errors makes it incomplete.

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

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

The schema describes both parameters ('Document ID' and 'XML content'), but these are generic and insufficient. The description adds no clarification about what the XML should contain (e.g., a styles.xml fragment, full style definitions) or how the docId is used. The description fails to enrich the parameter meaning beyond the basic 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 'Set document styles' is a verb+resource but lacks specificity. It doesn't clarify which styles or in what format, and it doesn't distinguish from the sibling 'docx.styles_get' beyond the action. A clear purpose would mention the XML structure or the scope of styles affected.

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. There is no mention of scenarios where setting styles is appropriate, nor any comparison with the get counterpart. The description leaves the user to infer usage entirely.

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 disclosure. It only says 'edit table content', implying a mutation but not explaining effects like persistence, undo, or what the `op` does. No information about side effects or requirements beyond the implicit mutating nature of 'edit'.

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 short, but for a tool with a nested `op` object, this is under-specification, not conciseness. Important behavioral details are missing, so the brevity is a negative.

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 this tool (nested op schema, no output schema, 3 required params), the description is grossly inadequate. It leaves agents clueless about what operations are supported, what arguments op might contain, or what the tool returns. There are no instructions on how to properly invoke it.

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?

While schema coverage is 100%, the parameter descriptions are extremely minimal ('Operation', 'Document ID', 'Table XPath'). The `op` property, which is the core of this tool, has no structure or allowed values described, and 'Operation' is tautological. The description adds no insight into how to construct a valid operation.

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

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

The description uses a clear verb ('edit') and resource ('table content'). This distinguishes it from siblings like 'get_table_content' and 'remove_table_row', though it doesn't explicitly call out those distinctions.

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

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

No guidance is given on when to use this tool versus the many table-related siblings (e.g., get_table_content, remove_table_row, find_empty_table_rows). The description is just the function's name restated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It simply says 'List all tables' without revealing what the output contains (e.g., table indices, names, metadata), whether it is read-only, or if it handles nested tables or pagination. The read-only nature is implied by 'list' but not explicitly stated, and other behavioral traits are absent.

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

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

The description is extremely concise and front-loaded, but it is underspecified. While brevity is good, the single sentence lacks crucial context about usage and behavior, making it too minimal for an effective tool definition. It is not appropriately sized because it could add a clause about what 'all' encompasses or what the output is, 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?

Given the simplicity (one parameter, no output schema), the description should at least hint at the return format or scope (e.g., 'all tables in the document'). It does neither. The presence of many sibling tools related to tables increases the need for contextual differentiation, which is entirely missing. The description is incomplete for an agent to confidently invoke and interpret 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 covers the only parameter (docId) with a 'Document ID' description, which is straightforward. The tool description does not add any parameter-specific meaning, but since the schema coverage is 100% and the parameter is simple, the baseline of 3 applies. No additional semantics are 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 'List all tables' clearly states a specific verb and resource, and the tool name reinforces this. It is unambiguous about what the tool does, but it does not differentiate from sibling tools like get_table_content or table_edit, which also deal with tables. Thus it is clear but lacks sibling distinction.

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

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

There is no guidance on when to use this tool versus alternatives such as docx.get_table_content or docx.find_empty_table_rows. It does not mention prerequisites, typical use cases, or why an agent might choose it over siblings. No context is provided beyond the bare purpose.

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 behavior. It states that all occurrences are returned (not just the first) and that coordinates are provided, which is useful. However, it does not explicitly state the operation is read-only (non-mutating) or describe the format of the returned coordinates (e.g., character offsets, line/paragraph numbers). For a find operation, these details are important for the agent to interpret results correctly.

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, direct sentence that front-loads the action ('Find text and return exact coordinates') and provides a purpose clue ('LLM can see where to edit'). It is concise with no filler, earning a high score for structure and 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?

The tool is relatively simple (search and return locations), but the description leaves a notable gap: it does not specify the structure of the coordinates (e.g., character indices, element paths, or page numbers). This is critical for an agent to act on the result when editing. It also does not mention whether the search is case-insensitive by default (though the schema covers that). Given no output schema, the description should more carefully describe the return format to be fully contextual.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (docId, searchText, caseSensitive). The description adds no extra semantic detail beyond hinting that the result includes coordinates. It does not clarify how caseSensitive interacts with the search or any edge cases. Given high schema coverage, a baseline of 3 is appropriate; the description does not compensate beyond that.

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

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

The description states a specific verb ('Find text'), resource ('text'), and outcome ('return exact coordinates of all occurrences'). It clearly distinguishes from siblings like docx.find (which likely just locates text) by emphasizing coordinates, and from editing tools like docx.replace_text. It also hints at its purpose ('LLM can see where to edit').

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 editing-by-locating text ('LLM can see where to edit') but provides no explicit guidance on when to use this tool versus alternatives like docx.find or docx.replace_text. It does not mention exclusions or prerequisites. The usage context is suggestive rather than directive.

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 says 'Replace text' without mentioning side effects, persistence, or whether it modifies the document in place. It does not clarify what happens with the existing text or whether changes are saved.

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?

One concise sentence, no fluff, and the key differentiator (coordinates vs. text search) is front-loaded. Efficiently conveys 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?

With five parameters and no output schema, the description should clarify whether the entire run text is replaced or only part of it, and what happens on invalid indices. It only says 'replace text in specific run' which is ambiguous about scope. Lacks detail 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?

Schema coverage is 100% with all parameters documented (docId, newText, runIndex, textNodeIndex, paragraphIndex). Descriptions are terse but accurate, adding minimal beyond the parameter names. Meets baseline for high schema coverage.

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

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

States a specific verb ('Replace') and resource ('text in specific run'), and clarifies it uses coordinates (paragraph/run/textNode indices). This clearly distinguishes it from more general tools like docx.replace_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?

Mentions 'precise word-level editing' which implies a use case for fine-grained control, but does not explicitly state when to use this over alternatives like docx.replace_text or when not to use it. The context is implied but not explicit.

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, what kind of output it returns, or any side effects or performance implications. The phrase 'LLM SEES' hints at the output but is vague about the actual return structure.

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

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

The description is short and to the point, front-loading the primary action. The use of 'ALL' and the parenthetical clarify scope efficiently. No wasted words, though the dash and 'LLM SEES' part is slightly informal but adds informative 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?

For a tool that analyzes all text runs and returns formatting details, the description is incomplete. It does not explain the output format, whether results are structured, or any limitations for large documents. Given extensive sibling tools and no output schema, agents would need more context to invoke it correctly.

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

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

The schema covers the single docId parameter with a basic description. The tool description adds no additional meaning to the parameter beyond what the schema provides. Since schema coverage is 100%, a baseline of 3 is appropriate.

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

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

The description clearly states the tool analyzes all text runs, specifically each <w:t> element, and mentions that the LLM sees every word/phrase with formatting. This distinguishes it from other text-related tools by emphasizing 'ALL' runs, but does not explicitly name a sibling for contrast.

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 one needs to inspect every text run with formatting, but it does not state when not to use it or mention alternatives. There is no explicit comparison with similar tools like get_text or read_paragraph_range.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the high-level purpose but does not disclose whether the operation is read-only, whether it can throw errors upon corruption detection, what it returns, or any side effects. This is a significant gap for a validation operation.

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

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

The description is a single, compact sentence that directly states the tool's purpose without redundant words. It is appropriately concise and front-loaded, with every word contributing to the meaning.

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 no output schema, so the description must explain what the agent can expect from calling it. It does not mention whether the outcome is a boolean, a report, or an exception, nor does it indicate prerequisites such as the document being open. This leaves the agent uncertain about how to interpret the result and when to call the tool.

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

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

The input schema already describes the sole parameter 'docId' as 'Document ID' with 100% coverage. The description does not add any additional meaning about the parameter, its format, or its relationship to the tool (e.g., whether the document must be open). Given the schema coverage is complete, the baseline of 3 is appropriate.

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

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

The description clearly states the specific verb 'Validate' and resource 'document structure' with the expected outcome 'detect corruption'. It is distinct from sibling tools which are operation-focused (open, close, save, etc.), making the purpose unambiguous. However, it lacks detail on what constitutes 'structure' and does not explicitly distinguish from any similar validation tool, though none appear present.

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

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

The description gives no guidance on when to use this tool versus the many sibling tools, nor does it mention prerequisites such as whether the document must be open. There is no mention of when validation is appropriate or what conditions should trigger its use, 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.