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

With no annotations provided, the description carries the behavioral burden. It explains parameter defaults and anchoring behavior, but does not explicitly state side effects such as modifying the file, whether an existing chart is replaced, or what return value or confirmation is produced. It adds some context beyond the schema but not comprehensive behavioral disclosure.

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

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

The description is well-structured with a clear purpose line and bulleted parameter explanations, making key details front-loaded and easy to scan. The competitive differentiation line adds some length but remains relevant to why this tool should be chosen.

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 7-parameter tool with no annotations and no output schema, the description covers most operational details but misses the required file_path and sheet parameters. It also does not explain any post-condition or confirmation behavior, leaving the description adequate but not fully complete for an agent needing to invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It adds useful meaning for data_range, chart_type, categories_range, title, and anchor_cell with concrete examples and defaults. However, it omits the required file_path parameter and the sheet parameter entirely, which are necessary for correct invocation.

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 inserts a chart and enumerates supported chart types, giving a specific verb and resource. It does not explicitly differentiate from sibling tools by name, but it does highlight its unique position relative to external skills/competitors.

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

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

The description provides clear context by noting that official xlsx skills lack chart guidance and the competitor does not support charts, implying this tool is the one to use when chart insertion is needed. It does not provide explicit exclusions or conditions for when not to use it, but the intended use case is reasonably clear.

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

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

With no annotations provided, the description carries the full burden. It states the tool uses openpyxl native rules and that they 'actually take effect,' which is helpful behavioral context. However, it doesn't disclose side effects like whether existing conditional formats are overwritten, whether the file is saved, or error conditions (e.g., invalid cell_range). It's adequate but not comprehensive.

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

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

The description is well-structured with a clear list of cond_type options and a brief parameters section. It's concise and front-loads the core info. The only minor redundancy is the '参数' list repeating some info already in the cond_type section, but it's not wasteful.

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 moderate complexity (6 params, 5 cond_type values), the description covers the essential logic for each type and gives examples. It lacks details on return values (but no output schema exists) and edge cases, but for an agent to invoke it correctly with the required parameters, it's largely sufficient. A perfect score would require more on error handling or effects.

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

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

Schema description coverage is 0%, so the description must compensate. It does well by explaining the purpose of each cond_type and linking them to the value/value2 parameters (e.g., 'between' requires value and value2). It also gives an example for cell_range. This adds significant meaning beyond the bare property names in the schema.

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

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

The description states it adds conditional formatting with openpyxl native rules and lists specific rule types, which clearly shows the tool's purpose. It's distinct from sibling tools like list_conditional_formats (which lists existing formats) and set_number_format (which sets number formats). However, it doesn't explicitly differentiate from all siblings, but the verb 'add' and resource 'conditional format' are specific enough.

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

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

The description gives clear guidance on when each cond_type is appropriate (e.g., which types require value, value2). However, there's no explicit mention of when to use this tool versus alternatives like list_conditional_formats or revert_last_write, nor are there exclusions or prerequisites. The context is implied but not fully spelled out.

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 behavioral burden. It discloses that aggregation is computed server-side, only one number per group is returned, and the output includes a TSV and equivalent Excel formula. It also surfaces a key failure mode (model-side summation). It doesn't explicitly state non-mutation or error behavior, but the main operational traits are covered.

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 well-structured with a concise overview, a critical usage warning, a bulleted parameter list, and a return-value note. Every section earns its place, and the most important behavioral guidance is front-loaded.

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

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

For a 7-parameter tool with no output schema, the description covers the return format, key parameters, and an important usage caveat. It lacks detail on file_path/sheet and edge cases, but the information needed to call the tool correctly is largely present.

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

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

Schema description coverage is 0%, so the description compensates by explaining column, op (with default sum), group_by, filters format, and top_n ordering. It leaves file_path and sheet unexplained, though those are largely inferable from context. The parameter explanations add meaningful value beyond the bare schema.

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

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

The description clearly defines the tool as server-side aggregation over a column, listing supported operations (sum/mean/median/etc.) and the output shape ('每组一个数字'). It doesn't explicitly name sibling alternatives like filter_count or create_pivot, but the operation list and grouped-result behavior make the purpose clear.

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

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

It gives explicit when-to-use guidance: use server-side aggregation rather than having the model iterate and sum data, warning that large-number addition is error-prone. It also references filter_count for filter syntax, which helps the agent reuse known format. It doesn't fully enumerate when to choose this over sibling tools, but the core usage context is present.

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 transparency burden and does a good job: it discloses the default font (Microsoft YaHei), the two-character-width calculation for Chinese, and the effect set (freeze, border, etc.). It does not explicitly say whether existing cell styles are overwritten or whether the file is saved in place, but the mutating formatting behavior is reasonably clear for a style tool.

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

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

The overview is front-loaded with the core effects, and the parameter list is compact. The rationale block is extra but supports correct usage; no sentence is wasted. It could be trimmed slightly by removing the repeated width 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?

The definition covers behavior and defaults well but lacks explicit guidance on the required file_path and sheet parameters and on what the tool returns or confirms. Given no output schema or annotations, these omissions leave an agent to infer part of the calling contract.

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

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

Schema description coverage is 0%, so the description must add meaning. It usefully documents four parameters (header_row, auto_width, freeze_header, font_name) and their defaults, but it omits the required file_path and the optional sheet parameter, so an agent is not fully told how to target the file/worksheet. This is partial compensation, not complete.

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

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

States a specific action ('套用中文场景样式') and names the concrete effects: Chinese-font header, auto column width, frozen first row, and thin borders. This clearly distinguishes it from narrower siblings like set_number_format or add_conditional_format.

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

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

The '为什么需要它' paragraph establishes the intended context: Chinese-table formatting where generic font guidance (Arial/Times New Roman) is unsuitable. It gives a clear when-to-use signal, though it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries the full burden and does well by disclosing the output shape: three categories of statistics and up to max_diff detail rows, with explicit truncation behavior. It also signals that the tool is read-only in spirit by emphasizing that it returns only a summary rather than the full sheet.

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

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

The description is compact and front-loaded with the core behavior, then gives use cases, then return details. Every sentence adds value and there is no redundant filler.

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

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

For a 6-parameter tool with no output schema and no annotations, the description is fairly complete about output and truncation behavior. It is missing semantics for compare_columns, which could matter for agents deciding how to restrict the comparison, and it does not describe edge cases like missing keys.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful semantics for max_diff (truncation limit) and key_column (comparison key), and '两个工作表' implies sheet1/sheet2. However, compare_columns is not explained, and file_path is left entirely to its name.

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 compares two worksheets by key column and returns only a difference summary, not the full table. The stated use cases (version comparison, change detection, reconciliation) further clarify its intended purpose. It does not explicitly name a sibling alternative, but the behavior is specific enough to distinguish it from tools like join_sheets.

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 '用途' section explicitly lists when to use the tool: version comparison, change detection, and reconciliation. This gives the agent clear context for choosing it, though it does not mention when not to use it or name alternatives such as join_sheets.

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 transparency burden, and it excels: it discloses that the tool injects real OOXML pivot parts, is validated with LibreOffice, lists unsupported features (grouping, calculated fields, slicers, etc.), and warns that LibreOffice interacts more weakly than Excel. This goes well beyond a typical description and preempts behavioral surprises.

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 well-structured with clear sections—difference from `create_pivot`, args list, and limitations—and it front-loads the key differentiator. Every sentence serves a purpose, and the length is appropriate for a complex tool with 10 parameters and significant caveats.

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 10-parameter tool with no annotations and no output schema, this description is remarkably complete: it covers purpose, alternatives, parameter meanings, and limitations. Yet it leaves `file_path` and `source_sheet` unexplained and does not mention what the tool returns (e.g., success message), which would be necessary for full standalone completeness.

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

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

The schema has 0% description coverage, so the description must compensate. It does explain the meanings of rows/columns/values, agg_func, page_fields, filters, target_sheet, and location, which covers most parameters. However, it omits `file_path` and `source_sheet` entirely, leaving those to be inferred from the schema or context, which is a minor 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 exactly what the tool does: 'Create an INTERACTIVE PivotTable (a real Excel PivotTable object).' It then contrasts this with `create_pivot` (static summary), making the purpose and distinction from the sibling tool immediately clear. The verb-resource pair is specific and unambiguous.

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

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

The description provides explicit guidance on when to use this tool versus `create_pivot`: use this when you need a real interactive Excel PivotTable with drag/expand/collapse/refresh, and `create_pivot` for fast static aggregations. It also gives a critical usage constraint—'Generate it LAST' because saving with openpyxl will drop the PivotTable—which prevents a common mistake.

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

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

With no annotations provided, the description carries the full burden. It honestly discloses the key limitation: openpyxl cannot create interactive pivots, so the result is a static summary. It also notes that it writes to a new worksheet, implying non-destructive behavior. This is transparent and useful.

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 moderately long but every sentence adds value. The warning about interactivity is essential, and the parameter list is structured and readable. It is front-loaded with the main purpose and then provides details, making it easy to scan.

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

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

Given the tool's complexity and lack of output schema, the description covers the necessary operational details: it mentions writing to a new sheet, filter format (referencing filter_count), and the limitation of static output. It doesn't explicitly state return values, but since the tool's effect is writing a sheet, that is implicit. It is sufficiently complete for an agent to call correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does so for rows, values, agg_func, columns, filters, and target_sheet, including examples and defaults. file_path and source_sheet are not explicitly explained, but they are self-explanatory from the tool's context. The description adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool generates a pivot summary table written to a new worksheet. It distinguishes itself from interactive pivots by explicitly noting it creates a static summary, which differentiates it from the sibling create_interactive_pivot.

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

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

The description provides clear guidance on when not to use it (when an interactive pivot is needed) and directs the user to Excel for that case. It doesn't mention other alternatives like aggregate, but the primary differentiator is covered. The context of writing to a new sheet is also clear.

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

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

With no annotations, the description fully carries the behavioral burden. It discloses that the tool returns only a count, samples a small number of rows by default, reports matched_pct, and returns an Excel COUNTIFS formula. It also clarifies the sample's purpose is only to confirm filtering, which is helpful behavioral context beyond the schema.

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

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

The description is well-structured and front-loaded: the core behavior appears first, followed by concise 用途/参数/返回 sections. Every sentence adds useful information without repetition or filler.

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

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

Even without an output schema, it describes the return fields (matched_rows, matched_pct, samples, Excel formula) and explains the sample's confirmatory role. Minor gaps remain: no explicit guidance on file_path/sheet and no named alternative tools, but overall it is sufficiently complete 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 0%, so the description must compensate. It adds strong semantics for filters, including the exact per-item object shape and the full list of supported operators, and explains the sample parameter's default and purpose. However, it does not document file_path or sheet, including that file_path is required, which leaves some parameters to be inferred.

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 gives a specific verb and resource: '按条件统计行数' (count rows by conditions), and explicitly scopes the tool to returning a count, not data rows. This clearly distinguishes it from siblings like read_range and top_n, which return row-level data or ranked rows.

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

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

It states when to use the tool: to answer 'how many rows satisfy X' questions, and adds context that counting is done server-side so thousands of rows never enter the context. It does not explicitly name alternatives or give when-not-to-use exclusions, so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden and does a good job: it discloses the row limit behavior, the column projection behavior, and the default join type. The phrase '只回传' implies a read-only result-returning operation, though it does not explicitly state that no file mutations occur.

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

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

The description is compact and well-structured: one sentence summarizes the core behavior, followed by a clean bullet list of parameter semantics. Every line adds value and nothing is redundant with the schema.

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

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

For a 7-parameter tool with no output schema and no annotations, the description covers the essential behavioral and parameter details. It could be more complete by explicitly describing the three file/sheet parameters and any edge-case behavior, but the current content is sufficient for an agent to invoke the tool correctly in most cases.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does this well for `on`, `how`, `columns`, and `limit`, adding meaning about key requirements, defaults, and token-saving intent. The three location parameters (`file_path`, `left_sheet`, `right_sheet`) are left to inference, but their names make the meaning obvious.

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 operation: joining two sheets like an SQL JOIN and returning only the first `limit` rows. This distinguishes it from sibling tools such as `compare_sheets` and `filter_count` by using the SQL JOIN framing, so an agent can immediately tell what this tool does.

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

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

The description gives clear context for when to use the tool: when two sheets need to be correlated via a key column. However, it does not explicitly name alternatives or state when not to use it, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden, and it does so well: it states the operation is read-only ('读取'), and discloses what is returned (rule count, range, type, operator, threshold formula, fill color, priority) and ordering. It does not discuss empty-result or error behavior, but for a read tool the key behavioral facts are present.

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

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

The description is front-loaded with the core action, then gives a practical use case, then the return details. Every sentence earns its place; there is no fluff or repetition of schema information.

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

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

The description compensates for the missing output schema by summarizing the returned fields and ordering. However, with no annotations and zero schema coverage, the lack of any guidance on the sheet parameter leaves a meaningful gap for an agent deciding how to invoke the tool.

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

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

Schema description coverage is 0%, so the description needed to explain file_path and sheet, but it adds no parameter-specific meaning. It does not clarify that sheet is optional, what null means, or which worksheet is targeted when sheet is omitted.

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

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

The description opens with a specific verb and resource: '读取工作表中已有的条件格式规则' (read existing conditional-format rules in the worksheet). It also positions the tool as the read half of a write/read loop with add_conditional_format, which clearly differentiates it from its sibling.

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 a concrete when-to-use scenario: '接手一张别人的表时' (when taking over someone else's sheet), in order to see existing automatic rules before modifying them. It does not name alternatives or exclusions, so it is clear context rather than explicit routing.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the exact approach (zero dependencies, direct scan of xl/media/), what is returned (image count, filenames, size, dimensions, with header parsing for PNG/JPEG/GIF/BMP), and a deliberate design limitation (returns only a list, not base64 image bodies, to avoid context overflow). This is a transparent and complete behavioral contract.

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 moderately long but every sentence earns its place: core action, rationale, return fields, and caveat. It is front-loaded with the main purpose and uses line breaks to separate sections, making it easy to scan despite its length.

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

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

For a simple one-parameter, read-only listing tool with no output schema, the description covers the essential behavior, return fields, and the key limitation. It lacks error-handling details and explicit file-path expectations, but an agent has enough information to invoke it correctly in the intended workflow.

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

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

Schema description coverage is 0%, so the description should compensate for the sole file_path parameter. It indirectly clarifies that file_path points to a workbook whose xl/media/ folder is scanned, but it never explicitly defines the parameter, accepted file types, or path format. The compensation is partial at best.

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

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

The description opens with a specific verb and object ('列出工作簿内的嵌图片' – list embedded images in a workbook) and states the mechanism (scanning xl/media/). It clearly distinguishes this from the sibling tools, which deal with cell data, formatting, or aggregation, making it immediately identifiable as the image-listing tool.

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

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

The description explains why this tool exists ('为什么需要它' – because other Excel MCPs silently discard images), which tells the agent when this tool is valuable. It also gives an explicit when-not: if the model needs to see image content, unzip and pass to a multimodal model rather than relying on this tool. It does not name a specific sibling alternative, but the context and exclusion are clear.

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

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

With no annotations, the description carries the full burden and does well: it discloses hidden-row handling, format-marker semantics, defaults, and the fact that hidden cells referenced by formulas are retained and marked. Minor gap: it promises a truncated indicator and skipped-count reporting, but the listed return fields do not include those values.

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 well organized with a front-loaded warning, a parameter list, format-marker explanations, and a return summary. Despite its length, every section adds necessary behavioral or semantic value, and the structure makes it easy for an agent to scan.

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

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

For a 7-parameter tool with no output schema, the description is unusually complete: it explains pagination, defaults, hidden-content behavior, format markers, and return fields. It is incomplete only in not listing truncated and skipped-count in the return summary and not documenting the required file_path 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 0%, and the description compensates by explaining sheet, cell_range, offset/limit, include_format, and include_hidden, including defaults and examples such as 'A1:D50'. It omits file_path, which is the only required parameter, leaving a small but notable gap.

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

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

The description clearly states it reads worksheet data with pagination, format semantics, and hidden-content handling, and the parameter list confirms the exact resource and scope. It is unambiguous from the name and siblings, though it does not explicitly differentiate itself from sibling read-like tools such as sheet_profile or workbook_info.

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

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

It gives explicit practical guidance: do not read large tables in one call, use limit/offset, and rely on the truncated indicator to detect remaining rows. It does not explicitly name alternatives or say when to choose another sibling tool, so it stops short of a 5.

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

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

With no annotations provided, the description fully discloses key behaviors: it mutates the workbook (recalculates), can permanently delete external links irreversibly, can fail silently if LibreOffice exits without writing, and requires LibreOffice to be installed. It also warns about the false positive of 'recalculation passed' not meaning 'result correct'. This is comprehensive behavioral disclosure that goes beyond what annotations would normally cover.

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 long but every sentence serves a purpose. It front-loads the core purpose and then logically groups safety, parameters, and returns. While concise would ideally be shorter, the density of critical information justifies the length. No fluff.

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

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

Given the complexity of this tool (recalculation with external link risks, silent failures), the description is complete. It covers prerequisites (LibreOffice), side effects (permanent deletion), and error handling. With no output schema, it also describes return values in sufficient detail. An agent has everything needed to decide and invoke 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 has 0% description coverage, so the description fully compensates by explaining every parameter: timeout for large workbooks, force for overriding external link risks, and file_path implied as the target. It also describes the return format (total_errors, errors_by_type) even though there is no output schema, which is extra value.

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

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

The description clearly states that the tool recalculates formulas and scans for errors, and it explicitly distinguishes itself from sibling tools by positioning it as a pre-delivery validation step. The phrase '重算公式并扫描错误' is a specific verb+resource, and the description differentiates it from tools like scan_formula_errors and read_range, which is genuinely useful.

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 explicit context for when to use it: after writing formulas with openpyxl, because read_range would return None otherwise. It also explains when not to use it in risky situations (external links) and provides details about the force parameter as a conditional alternative. This is unusually thorough guidance.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that the tool restores from a .bak file, retains only the most recent backup, and that consecutive writes make it roll back the last write. This is meaningful context, though it does not cover edge cases like what happens if no backup exists or whether the rollback is destructive to concurrent changes.

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

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

The description is short and front-loaded: it states the action and mechanism first, then gives the trigger condition and the backup-retention caveat. Every sentence earns its place with no filler or repetition.

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

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

This is a low-complexity tool with one parameter and no output schema. The description covers what it does, when to use it, and a key limitation. However, it does not mention failure behavior when no backup exists, nor what the return/response signals after a rollback, so it is slightly incomplete.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented file_path parameter. It does not explain what file_path refers to (e.g., the file whose last write should be reverted, or the path to the .bak file). The parameter name is self-explanatory at a basic level, but the description adds no semantic value beyond the schema.

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

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

The description states a specific verb ('回滚' / roll back) and resource ('最近一次由本服务执行的写入' / the most recent write performed by this service), and even mentions the .bak restore mechanism. It clearly differentiates itself from write_cells and the other sibling tools by identifying its exact operation: undoing the last 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?

The description explicitly says when to call it: '当 write_cells 的结果不符合预期时调用它撤销' (call it to undo when write_cells results are unexpected). It also warns about an important limitation: only the most recent backup is kept, so consecutive writes will roll back only the last one. This is clear usage guidance with no ambiguity.

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

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

With zero annotations, the description carries the full transparency burden and does well: it discloses that the tool only scans (no recalculation), returns total_errors with per-type location details, truncates the location list beyond 100 entries with an explicit truncated-count message, and warns that severity should be judged by total_errors, not list length. It doesn't address edge-case behavior (e.g., empty result format or missing file), which keeps it from a 5.

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

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

The description is compact and well-organized: the key differentiator (scan-only, no recalc) is front-loaded in the first line, followed by purpose, then return semantics and truncation warning. Every sentence carries distinct information — error types, no-recalc clause, use case, return structure, and interpretation guidance — with zero waste.

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

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

Given there is no output schema, the description appropriately explains the return values (total_errors, grouped location details, truncation count) and how to interpret them correctly. For a single-parameter scan tool with no annotations, this is complete — the agent knows what file to pass, what will be returned, and how to avoid misreading truncated 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?

Schema description coverage is 0%, so the description must compensate for file_path. It adds slight meaning by specifying '现有文件' (existing file), implying the target must already exist and is not modified. However, file_path is largely self-explanatory, and the description provides no format, path-type, or validation details, so the compensation is modest.

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: scan only formula errors, enumerating the exact error types (#VALUE!, #DIV/0!, #REF!, #NAME?, #NULL!, #NUM!, #N/A). It also explicitly distinguishes itself from 'recalculate' with '不重算' (does not recalculate), making its scope unambiguous relative to its siblings.

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

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

The use case is clearly stated: '快速体检现有文件是否有坏公式' (quickly check whether existing files have bad formulas). The '不重算' phrase provides an implicit exclusion against the recalculate sibling, but it doesn't explicitly name alternative tools or state when NOT to use this one, so it stops short of full routing guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does add useful behavioral details, such as the requirement that percent values must be stored as decimals (0.15 displays as 15.0%) and that cny_dash displays zero as a dash. However, it does not disclose whether existing formatting is overwritten, how invalid custom codes are handled, or what the function returns after success.

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

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

The description is compact and front-loaded with the core purpose, followed by a clean mapping of format codes to their meanings. The list is easy to scan, though a small amount of structure could be improved by separating the int and date mappings onto their own lines.

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

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

The description provides enough information to select valid values for the main parameter, but it omits important contextual details for a mutating tool: whether it saves to the file, overwrites existing formatting, handles custom format code syntax, or what it returns. Since there are no annotations and no output schema, these gaps make it less than fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly documents the number_format parameter, including exact code strings and display behavior, which is especially valuable because the schema has no enums or descriptions for that parameter. The other parameters (file_path, cell_range, sheet) are left implicit, but their names are reasonably self-explanatory in this spreadsheet context.

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

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

The description clearly states the tool sets number formats, and the detailed list of built-in format codes clarifies exactly what kind of formatting is supported. It does not explicitly mention the target resource (file/cell range), but the schema and naming make that evident, and it is distinct from sibling tools like write_cells and apply_chinese_style.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or how it relates to sibling tools like write_cells or apply_chinese_style, leaving the agent to infer the appropriate context.

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

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

With no annotations provided, the description carries the full burden, and it delivers meaningful behavioral detail: it promises not to put data rows into context, reports _meta.tokens_saved, and states that the first row is treated as the header. It does not explicitly say the operation is read-only or describe error behavior, but the key consumption-relevant traits are disclosed.

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 well-structured with a bold front-loaded directive, a short parameter list, and a return-value list. It is slightly longer than strictly necessary and repeats some field details, but every sentence contributes practical value and the layout aids scanning.

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 does a good job of explaining return values (dtype/null_pct/unique/top_values/stats) and the token-saving metric. However, the required file_path parameter is not explained at all, and there is no mention of failure modes or read-only guarantees, leaving a meaningful completeness gap.

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

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

Schema description coverage is 0%, so the description must compensate. It documents the sheet parameter well — omission uses the active sheet and implies first-row-as-header — but it completely omits file_path, which is the only required parameter. The '参数：' section misleadingly lists only one parameter, leaving a required argument undocumented.

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

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

The description opens with a specific verb and resource — '查看工作表的列级画像' (view column-level profile of a worksheet) — and enumerates the exact profile fields (类型、空值率、唯一数、Top 值、数值统计). The bold directive also positions it distinctly from siblings as the first tool to call before analysis, making its purpose and scope unambiguous.

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

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

The description gives an explicit when-to-use instruction: '开始分析任何表格前最该先调用的工具' (the first tool to call before analyzing any table), and justifies it by saying it saves a dozen probing calls. However, it does not name sibling alternatives or state when NOT to use this tool, so the exclusion guidance is left implicit.

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

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

With no annotations, the description carries the behavioral disclosure burden. It explains that sorting happens server-side, that only N rows are returned rather than the full table, and that the output includes ranked rows, TSV, and an Excel RANK formula. It does not explicitly state read-only behavior, but the wording strongly implies a non-mutating query.

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

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

The description is compact and well-structured: core behavior first, then use case, then parameter details. Every sentence adds value, and the formatting makes it easy to scan.

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

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

For a tool with no output schema and 7 parameters, the description covers the main behavior, use case, parameter semantics, and return format. It relies on a reference to filter_count for filter syntax, which is acceptable given the sibling relationship, and does not mention edge cases like n exceeding row count, but overall it is sufficiently complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does. It explains sort_by, n, ascending, columns, and filters, including defaults and the purpose of columns for token savings. The only unmentioned parameters are file_path and sheet, which are self-evident from the schema.

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

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

The description clearly states the tool's function: take sorted rows and return only the top N, with a specific default ordering. It also distinguishes itself from a full-table read by emphasizing that sorting is done server-side and only the TopN rows are returned, not the whole table.

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

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

It explicitly identifies the intended use case: ranking/leaderboard questions such as 'top 10 products by sales'. It does not explicitly name alternative tools or state when not to use it, but the use-case framing gives clear contextual 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 burden of behavioral disclosure. It enumerates the return payload (file path, size, active sheet, per-sheet metrics) and explains that the tool avoids loading the full sheet into context, implying a lightweight metadata-only operation. It does not explicitly state read-only semantics, but the wording strongly implies it.

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

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

The description is compact and well-organized: the first sentence lists the concrete outputs, and the second section adds usage rationale and return fields. Every sentence adds value and there is no filler or redundancy.

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

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

For a simple one-parameter inspection tool with no output schema, the description is nearly complete: it explains what the tool does, when to call it, and what it returns. It omits error/precondition details, but these are not critical for such a straightforward informational 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 only parameter, file_path, has no schema description and the description does not elaborate on its expected format or constraints. The parameter name is self-explanatory and the description references 'Excel 文件', providing some context, but with 0% schema coverage the description should have compensated more explicitly.

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

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

The description clearly states the tool's function: inspect an Excel workbook's structure, listing sheets, row/column counts, merged cells, hidden rows/columns, images, and file size. This is a specific verb+resource. However, it does not explicitly differentiate itself from the sibling tool sheet_profile, which may provide overlapping per-sheet structural information.

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

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

The description explicitly advises calling this tool before processing any Excel file, giving a clear when-to-use instruction. It does not, however, name alternatives or state when not to use it, so it stops short of full routing guidance.

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

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

With no annotations present, the description carries the full burden and delivers: writes are atomic, a .bak backup is created, revert_last_write can roll back, formulas are recognized by '=' prefix, and there is a 100k-cell limit. This goes well beyond the bare schema.

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

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

The description is front-loaded with the batch mandate, then uses compact labeled sections for parameters, safety, and limits. Every sentence adds operational value; no filler.

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

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

For a 4-parameter mutation tool with no annotations and no output schema, the description covers purpose, all non-obvious parameters, safety/rollback behavior, and hard limits. Nothing required to call it correctly is missing; return-value detail is not essential for a write 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 coverage is 0%, so the description must add meaning. It thoroughly explains cells (list of {cell, value} objects and formula behavior), sheet (defaults to active sheet), and create_sheet_if_missing (default False). Only file_path is not discussed, though its name/title makes it self-explanatory.

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

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

The description opens with a specific verb and resource ('批量写入多个单元格') and immediately frames it as a batch interface. It distinguishes itself from a single-cell write loop, so an agent knows exactly what the tool does and how it differs from the naive alternative.

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

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

It explicitly instructs '请在一次调用里传入所有要写的单元格' and warns '不要用单格写入循环调用', giving a clear when-to-use and when-not-to-use. It also explains the rationale (single file read/write cycle vs slow repeated backups) and notes create_sheet_if_missing defaults to False to avoid accidental sheet creation.

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