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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds value by explaining type-awareness (skips non-numeric values cleanly). No contradictions.

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

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

Concise and well-structured: functional description, behavioral note, clear usage guidelines. No wasted words.

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

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

Describes return format (markdown table), type-awareness, and usage boundaries. Could mention edge cases or performance notes, but overall adequate for complexity.

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

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

Schema coverage is 0%, so description must compensate. It gives a conceptual mapping to pandas groupby but doesn't explain each parameter individually. Provides context but not per-parameter details.

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 performs pandas-style groupby aggregation on local .xlsx files with specific functions (sum, mean, etc.). It differentiates from sibling tools like xlsx_filter and xlsx_pivot by stating when to use and when not to use.

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

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

Explicitly states when to use (user asks for totals/averages/counts by group) and when not to use (for individual rows or 2D pivot). Names alternatives (xlsx_filter, xlsx_pivot), providing clear 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?

Annotations provide readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds context by stating it returns the spec (not pixels), explains sheet attribution via OOXML drawing rel chain, and confirms no rendering. No contradictions, and it enriches understanding beyond annotations.

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

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

The description is concise and well-structured, with a clear opening sentence, a brief example, and USE WHEN/DO NOT USE WHEN sections. Every sentence adds value without redundancy.

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

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

The description covers what the tool does and when to use it, but lacks parameter explanations (0% coverage). With no output schema, it partially compensates by describing the return content. However, for a tool with two parameters and nested objects, more detail on parameters is needed for full 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?

Schema description coverage is 0%, meaning the description does not explain any parameters (file_b64, options with limit and sheet). The description mentions 'limit' and 'sheet' indirectly but does not elaborate on their purpose or constraints, leaving a significant gap for parameter usage.

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

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

The description clearly states 'List every chart in a LOCAL .xlsx file' with specific details like chart type, title, axis titles, and per-series formula refs. It distinguishes from siblings by noting that xlsx_read is for cell values, making the purpose unambiguous.

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

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

Explicit USE WHEN and DO NOT USE WHEN sections provide clear guidance. It specifies documenting financial models or auditing for drift as use cases, and warns against using for rendering or cell values, directing to xlsx_read as an alternative.

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

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

Annotations already declare readOnlyHint=true and other safety traits. The description adds beyond this by detailing internal behavior: mapping personId to display names via a specific XML file, folding reply chains into root comments, and mentioning the free-tier 10k/mo cap. No contradiction with annotations.

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

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

The description is well-structured with clear sections (USE WHEN, DO NOT USE WHEN) and front-loads the core purpose. While every sentence adds value, it could be slightly trimmed (e.g., the technical details about OOXML zip are helpful but may be secondary). Overall, it earns 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?

Given the complexity of handling two comment systems and no output schema, the description is highly complete. It explains the scope, limitations (e.g., cannot add comments), and technical details (personId mapping, reply chains). Annotations cover safety, so the description focuses on behavioral and contextual aspects effectively.

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

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

Schema coverage is 0%, meaning the input schema lacks descriptions. The description does not explain the parameters (file_b64, options.limit, options.sheet) beyond their existence. It relies on context, but agents would benefit from explicit parameter guidance. This is a significant gap for a 2-parameter tool with nested objects.

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

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

The description specifies a precise verb ('list') and resource ('every cell comment in a workbook'), covering both legacy notes and threaded comments. It explicitly distinguishes itself from siblings by noting that no other tool (including pandas and openpyxl) can do this, providing clear differentiation.

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

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

The description provides explicit USE WHEN and DO NOT USE WHEN sections. It lists specific scenarios (extracting reviewer feedback, auditing, building reports) and clearly states when to use alternatives (xlsx_read for values, notes that xlsx_write does not write comments). This gives agents strong guidance on tool 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?

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds context: lists output contents (range, type, operator, formulae, priority, stopIfTrue) and mentions a per-type tally, plus notes the tool counts against a monthly cap. No contradictions with annotations.

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

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

The description is well-structured with clear sections (list of rules, uniqueness claim, USE WHEN, DO NOT USE WHEN). It is slightly verbose but each sentence adds value. Could be more concise but not overly long.

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

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

The description covers the tool's output (per-rule details, tally) and usage contexts well, but lacks parameter documentation. No output schema exists, so the description should compensate by explaining expected input (file_b64, options) but does not. Additionally, it does not explain error conditions or file size limits beyond the 10k cap.

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

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

Schema has 2 parameters (file_b64, options with limit/sheet) with 0% description coverage. The description provides zero information about these parameters: no explanation of file_b64 (base64-encoded file), limit, or sheet. The agent is left guessing parameter meaning and constraints. Severe 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 defines the tool's purpose: listing every conditional formatting rule in a workbook, specifying rule types (color scales, data bars, icon sets, etc.) and per-rule details. It explicitly distinguishes itself from siblings by noting that pandas drops conditional formatting and openpyxl lacks rollup/classification, making the tool unique.

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 USE WHEN and DO NOT USE WHEN sections, citing specific audit/scenario contexts (e.g., auditing dashboards, extracting business rules) and alternatives (use xlsx_read for cell values, xlsx_write cannot re-apply CF rules). Also notes the free tier cap (10k/mo). Excellent 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?

Annotations indicate readOnlyHint=false, destructiveHint=false, idempotentHint=false. The description adds value by explaining that text formats render in the response body for agent reading, while binary formats return bytes in _meta.file_b64 for client saving. This goes beyond annotations and clarifies behavioral aspects.

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 fairly long but well-structured with sections for purpose, usage, and output behavior. It front-loads the core function and uses bullet-like lines for guidelines. A slight reduction in redundancy could improve conciseness, but it remains effective.

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 handling multiple formats and output behaviors, the description is complete. It explains input format variety, output format options, usage guidelines, and return value handling for both text and binary. No output schema exists, so the description adequately covers what the tool returns.

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 only 33%, but the description compensates by explaining the purpose of file_b64, the options object (with sheet and sheets), and the to parameter format targets. It adds behavioral context about text vs binary output for the to parameter, which is not 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 clearly states it is a 'universal spreadsheet format converter' that reads 25+ input formats and emits many output formats. It distinguishes itself from siblings like xlsx_read by emphasizing legacy format support, making the purpose unambiguous.

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

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

The description provides explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, detailing when to use this tool (e.g., for legacy formats) and when to use alternatives (e.g., xlsx_read for xlsx). It also explains output behavior differences between text and binary formats.

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

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

Discloses key behaviors beyond annotations: informer-not-enforcer pattern (findings for accept/reject/override), diagnose vs execute modes. Annotations show destructiveHint=false and readOnlyHint=false, but description contextualizes mutation with user consent, adding valuable transparency.

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

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

Two focused paragraphs: first describes functionality, second usage guidance. Every sentence adds value, no redundancy. Front-loaded with key actions.

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 complexity (8 params, no output schema), description covers purpose, usage, behavior, and parameter context well. Missing details on return format (e.g., Finding structure) and file limitations, but sufficient for high-level understanding.

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

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

Schema has 0% description coverage; description compensates by explaining mode, options, and workflow (diagnose/execute, findings, overrides) but does not explicitly detail each parameter or their types, leaving some interpretation to the schema. Still provides meaningful semantic 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's purpose: AI-native data cleaning for local .xlsx files, listing seven specific data issues it addresses. It explicitly distinguishes from siblings (e.g., xlsx_doctor, dedicated pipelines), making purpose unambiguous.

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

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

Explicitly provides when to use (upstream messy xlsx for LLM/analysis) and when not to use (domain transforms, structural checks, uploads), with specific sibling alternatives, offering excellent 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. Description adds detail about what validations are listed (target cells, formulae, error messages, prompt text) and that it surfaces them in one shot. No contradictions with annotations.

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

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

The description is well-structured, front-loaded with purpose, uses 'USE WHEN'/'DO NOT USE WHEN' for clarity, and every sentence adds value. No 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?

Covers the tool's action, use cases, and output fields, but lacks parameter descriptions. Given no output schema, the description partially compensates by mentioning returned data (target cells, formulae, etc.). Missing parameter details reduces completeness slightly.

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

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

Schema description coverage is 0%, and the description does not explain the parameters (file_b64 and options.sheet). It does not mention that file_b64 is a base64-encoded Excel file or provide guidance on the optional sheet parameter. This leaves the agent to infer from 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 lists cell-level data validation rules (dropdowns, bounds, text-length caps, custom formulas). It distinguishes from siblings by noting that other tools cannot do this in one shot, providing specific examples of what it returns.

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

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

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide concrete scenarios: auditing forms, extracting dropdowns, generating fixtures vs. reading values (use xlsx_read) or enforcement on write (xlsx_write does not write validations). Also mentions free tier cap.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that the tool does not silently flatten merged cells or drop named ranges, which is useful behavioral context. However, it does not elaborate on other aspects like authentication or rate limits.

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 concise with front-loaded key information, but it could be more streamlined. It includes a useful pandas comparison and usage guidance, but the lack of parameter details is a structural gap.

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

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

Given the tool has a nested options parameter with three sub-properties and no output schema, the description fails to explain how to use these parameters or what the markdown table output contains in detail. This leaves significant gaps for the agent.

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

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

The input schema has 0% description coverage, and the tool description provides no information about parameters such as file_b64 or options (header_row, max_rows, sheet). The agent must infer usage solely from the schema names, which is insufficient.

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

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

The description clearly states it performs a pandas-style df.describe() per column, listing statistics like count, nulls, unique, min/max/mean/std for numerics, and dtype with purity score. It distinguishes itself from a naive pandas approach and explicitly mentions returning a markdown table, making the tool's purpose unambiguous.

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

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

The description includes explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, guiding the agent to use this for quick summaries of local .xlsx files and to avoid it for uploaded files or in-memory data. It also compares favorably to xlsx_read for speed, but does not name specific sibling alternatives like xlsx_value_counts.

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

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

Annotations declare idempotentHint=true, and the description adds detail about byte-deterministic output and diff_hash for caching. No contradictions with annotations. The description provides useful behavioral context beyond the annotations.

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

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

The description is relatively concise and front-loaded with the key purpose. However, it omits parameter details and could be restructured to include them without adding much length. It is not overly long, but missing important information prevents a higher score.

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

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

Given no output schema and 0% schema coverage, the description should explain the return format (e.g., what diff_hash is, how to interpret the diff) and clarify the base64 parameter mapping. The current description is insufficient for an agent to correctly use 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 description mentions 'local .xlsx files' but the schema expects base64 strings (file_a_b64), creating a mismatch. The optional sheet parameter in options is not explained. With 0% schema description coverage, the description should clarify parameter meaning, but it fails to do so, likely confusing an agent.

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 computes a semantic diff between two local .xlsx files, listing specific outputs (cell-level deltas, formula changes, added/removed rows). This distinguishes it from siblings like xlsx_read or xlsx_validate.

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?

Explicit USE WHEN and DO NOT USE WHEN sections provide clear guidance, specifying that the tool is for local file paths and not for uploads/attachments. This helps the agent select the tool appropriately.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. Description adds value by stating it's a single round trip, outputs ranked findings, and should be called first. No contradictions.

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

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

Well-structured: begins with purpose, lists scan items, explains output format, then provides usage guidance. Every sentence adds value; 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?

Despite lacking an output schema, description thoroughly explains what the report contains (ranked findings, quick_facts). Covers what is scanned and how output is organized. Complete for an audit 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?

Only one parameter (file_b64) with no schema description. The description implies the file is local and base64-encoded by stating 'local .xlsx file', but does not explicitly state the parameter is base64 content. Partially compensates.

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

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

Description clearly states it generates a workbook health report for local .xlsx files, listing specific items scanned (macros, references, hidden sheets, etc.). It distinguishes itself from sibling tools by branding as a 'ONE-CALL' health report and contrasting with focused tools like xlsx_macros and xlsx_read.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear context for when to call this tool versus alternatives. It recommends using this before any other tool for triage and advises against it when already looking for specific issues or data values.

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

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

Describes the evaluation engine (HyperFormula), replacement of cached values, and intentional omission of I/O-related functions. Annotations already indicate read-only and idempotent behavior; description adds context about local evaluation and limitations.

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

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

Well-structured with a concise summary, followed by usage guidance. Every sentence adds value without redundancy. Information is front-loaded and easy to scan.

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

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

The description covers the tool's purpose, usage context, and limitations well. However, with no output schema, it does not describe the return format or structure of the evaluated results, which could leave the agent unsure of what to expect.

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 description compensates partially by explaining the two modes (cells and formulas) and their purpose. However, the required file_b64 parameter is not described in detail (base64 format not mentioned), and options object only gets a brief mention. A more explicit description of each parameter's role and constraints would improve the score.

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

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

Clearly states the tool evaluates Excel formulas against a local .xlsx file via HyperFormula. Distinguishes from sibling tools like xlsx_read (for no formulas) and describes two modes (formulas and cells).

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

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

Provides explicit USE WHEN and DO NOT USE WHEN sections, specifying conditions and alternatives. Mentions omission of risky functions like INDIRECT and HYPERLINK, guiding proper use.

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?

Beyond annotations (readOnlyHint=true, etc.), the description reveals it reads xl/externalLinks/*.xml directly, warns about absolute paths/network shares, and mentions the free tier cap (10k/mo). No contradictions with annotations.

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

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

The description is well-structured with separate paragraphs for purpose, comparison, USE WHEN, and DO NOT USE WHEN. Every sentence adds value without redundancy.

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

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

Despite no output schema, the description specifies exactly what is returned per link (target path, classification, sheets, cached values, named ranges) and contextual warnings. This is comprehensive for the tool's complexity.

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

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

The only parameter `file_b64` is not explicitly described, and schema description coverage is 0%. However, its purpose is implied by the tool name and description, so it is adequate but not enhanced.

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 lists external workbook references, provides specific examples like `=[Budget.xlsx]Sheet1!A1`, and contrasts with sibling tools by noting that pandas, openpyxl, and ExcelJS cannot do this consistently. This distinguishes it effectively from the many sibling xlsx tools.

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

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

The description explicitly states USE WHEN scenarios (e.g., sending a workbook, auditing leaked file paths, dependency analysis) and DO NOT USE WHEN (just reading values, directing to xlsx_read). This provides clear decision 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?

Beyond annotations (readOnly, idempotent, etc.), the description adds critical behavioral details: formulas are evaluated server-side (not cached results), returns markdown table capped at 1000 rows with actual match count. No contradiction with annotations.

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

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

The description is concise and well-structured: it opens with the core purpose, followed by behavioral context, then clear usage guidelines. Every sentence adds value without redundancy.

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

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

Given the tool's complexity (nested objects, no output schema), the description covers purpose, usage, behavioral traits, and key parameter aspects. It could further detail the output format or options like header_row, 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?

With 0% schema coverage, the description compensates by explaining that predicates are AND-combined and listing supported operators. However, it does not describe other parameters like file_b64, header_row, or sheet, leaving some reliance on 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 it performs a 'pandas-style row filter' on a local .xlsx file with AND-combined predicates, and explicitly distinguishes it from xlsx_read for raw access. The verb 'filter' and resource 'LOCAL .xlsx file' are specific.

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 includes explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, directing agents to use this tool when the user requests filtered rows and to avoid it for raw access (use xlsx_read) or for uploaded files.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by disclosing the free tier limit (10k/mo cap) and explaining the internal implementation (reads xl/ctrlProps/ctrlProp*.xml directly). No contradictions.

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

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

The description is well-structured, front-loaded with the core purpose and capabilities, followed by usage guidance. Every sentence adds value, no fluff. The length is appropriate for the tool's complexity.

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 annotations and no output schema, the description is complete. It covers return content, constraints (free tier, cap), and usage contexts. It does not need to explain return values since no output schema exists, but the description details what is returned.

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?

Input schema has 2 parameters with 0% description coverage. The description does not explain what file_b64 or options.sheet mean or how to use them. Although parameter names are somewhat self-explanatory, the description fails to add semantic meaning beyond the raw schema, leaving a gap for agents.

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 what the tool does: 'list every form control ... in a workbook' with specific details (linked cell, current value, etc.). It also distinguishes from siblings by noting that no other tool gives this in a single call and contrasts with ExcelJS, pandas, and openpyxl limitations.

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 provides 'USE WHEN' scenarios (documenting survey workbook, scoring rubric, auditing) and a 'DO NOT USE' scenario ('just reading values' with a specific alternative, xlsx_read). This gives clear guidance on when to choose 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?

Annotations already indicate readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds the important constraint that the workbook must be LOCAL and that the tool performs openpyxl-style read-only metadata extraction, which clarifies its behavior beyond annotations.

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

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

The description is concise and well-structured, with a clear front-loaded purpose statement, a distinction from sibling tool xlsx_read, and explicit usage guidelines in a compact format. No extraneous information.

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

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

Given the tool's complexity (2 parameters, no output schema, many siblings), the description provides strong purpose and usage guidance, and hints at output structure. However, the lack of parameter explanations and output schema leaves some gaps, particularly for optimizing use of options like limit and sheet.

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

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

Schema description coverage is 0%, yet the description does not explain any parameters (file_b64, options, include_results, limit, sheet). It only describes the output format (cell coord, formula text, cached result), leaving the agent without guidance on how to use the parameters effectively.

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 extracts every formula from a local .xlsx workbook, returning cell coordinates, formula text, and cached results. It distinguishes from xlsx_read, which returns evaluated values, making the purpose 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 'USE WHEN' and 'DO NOT USE WHEN' sections, guiding the agent to use this tool for formula auditing and to avoid it for computed values (recommending xlsx_read instead). It also notes that pandas cannot extract formulas, reinforcing uniqueness.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false; the description adds that the tool returns 'cured workbook bytes + receipt' and lists specific operations, providing context beyond the annotations. However, it does not explicitly describe the behavior for as_copy vs in_place modes.

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

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

The description is well-structured with clear sections and front-loaded purpose, but the list of operations is somewhat dense. It is appropriately sized for the tool's complexity.

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, no output schema, and 0% schema coverage, the description covers the main purpose, operations, and usage guidelines, but lacks explanations for 'cure_params' and 'intent' parameters, making it incomplete.

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

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

Schema coverage is 0%, so description must compensate. It explains the 'operation' parameter by listing allowed values, and implies 'file_b64' is the workbook file, but it does not describe 'cure_params', 'intent', or 'mode' parameters, leaving a significant 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 'Apply ONE specific cure operation against a diagnosed workbook' and lists the supported operations, clearly distinguishing it from sibling tools like xlsx_healer_diagnose and xlsx_healer_intent.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear context for when to use this tool versus alternatives (e.g., xlsx_healer_intent for goal-shaped fixes), and prerequisites (diagnose must have been run).

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

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

Annotations already declare read-only and idempotent. Description adds detail on output structure (five finding classes with ref_id keys) and input requirement (source bytes, no reconstruction from spec). No contradictions.

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

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

Efficiently structured: purpose statement, enumerated findings, usage guidance. No redundant text. Front-loaded with main action.

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

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

Single parameter description implicitly clear. Covers purpose, output structure (five finding classes with reference_ids), usage scenarios, and exclusions. No missing needed context for agent to decide.

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 lacks any description for file_b64. The description indirectly explains it's the source bytes of the .xlsx file, but doesn't specify encoding or constraints. Adds some value over schema but leaves gaps.

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

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

Clear verb+resource with enumerated finding types. Explicitly distinguishes from sibling xlsx_data_clean and indicates relationship to healer_cure. 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?

Explicit when to use with concrete examples, and when not to use with alternative tool named. No gaps.

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

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

Annotations indicate non-read-only, non-destructive, non-idempotent, and open-world. Description adds behavioral context: it returns planned operations, cured bytes, and an unactionable list, and explains the three intents. No contradictions. Some details about authentication or rate limits missing, but adequate given annotations.

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

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

The description is relatively concise and well-structured, with a clear purpose statement, intent breakdown, and usage guidelines. It could be slightly more compact by trimming redundant phrases, but overall 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 tool with 6 parameters (2 required), no output schema, and nested objects, the description covers the main intent parameters and usage. However, it leaves some ambiguity about the return format ('unactionable list' is not explained) and how planning works. With no output schema, more detail would be helpful.

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

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

Schema description coverage is 0%, but description compensates by explaining the three intents and their meanings (e.g., 'make-it-work: minimum surgery to clear errors'). Also describes intent_params with from/to. However, parameters like confirm, mode, operation are not explained, leaving some gaps.

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

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

The description clearly states the tool's purpose: goal-driven healing where the user declares an intent (make-it-work, make-standalone, migrate) and the tool plans and applies operations. It also distinguishes from sibling tools like xlsx_healer_cure by emphasizing the goal-driven approach.

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

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

Explicitly states when to use (user describes goal in plain English, multiple operations needed) and when not to use (specific cure operation chosen, no diagnostic run). Provides clear alternatives, making it easy for the agent to decide.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds that it is read-only, produces no output workbook, and only simulates. No contradictions. Could detail decoding of file_b64, but sufficient overall.

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 short paragraphs: purpose, when to use, when not to use. Every sentence adds value. Front-loaded with the primary action. No unnecessary words.

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

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

Given no output schema, the description explains what the tool returns: which references resolve and which break with reasons. It covers behavior, inputs, and usage boundaries. Slightly vague on output format, but sufficient for agent decision.

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 explicitly names 'accessible_paths' and explains its role. 'file_b64' is implied as the workbook. Minor improvement: clarify file_b64 is base64-encoded XLSX.

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 simulates recipient-side accessibility of external references, using specific verb and resource. It distinguishes from siblings xlsx_healer_cure and xlsx_healer_intent by explicitly contrasting when to use vs when not.

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 'USE WHEN' and 'DO NOT USE WHEN' sections with concrete examples (e.g., before sharing to Slack) and direct alternatives (xlsx_healer_cure, xlsx_healer_intent). This is optimal 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?

Annotations already mark it readOnly, destructiveHint false, idempotent. Description adds 'does not fetch — by design, for safety', confirming it's a pure read operation. No contradiction.

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

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

The description is moderately long but well-structured: purpose sentence, competitive advantage, use cases, and exclusions. Every sentence adds value, though the 'Free tier' note could be integrated more concisely.

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 2 params (1 required), no output schema, but rich annotations, the description is fairly complete: it explains output fields, use cases, and limitations. Missing detail on file_b64 encoding and output format, but acceptable for a simple tool.

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

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

Schema coverage is 0% (no parameter descriptions in schema). Description does not explain the input parameters (file_b64, options with limit and sheet) beyond implying a workbook input. This is insufficient compensation for the lack of schema 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 clearly states the tool lists hyperlinks with specific fields (anchor cell, target URL, display text, tooltip, kind classifier). It distinguishes from siblings by noting pandas drops hyperlinks and openpyxl doesn't classify/aggregate, making the purpose specific and differentiated.

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?

Explicit USE WHEN and DO NOT USE WHEN sections provide clear context: security auditing, URL extraction, not for fetching targets or reading cell text (redirects to xlsx_read). Also mentions free tier cap.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, etc. Description adds that it reads xl/media/* and xl/drawings/* directly and returns metadata only, not pixel data. No contradictions.

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

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

Well-structured with a clear main statement, an example, and distinct usage sections. Slightly wordy but front-loaded and easy to follow.

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, the description adequately explains return values (format, size, sheet, anchor). Mentions local file requirement. Does not specify pagination or base64 encoding but schema covers limit and required field.

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

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

Schema coverage is 0% (no parameter descriptions). The description does not explain file_b64 (base64) or the options.limit and options.sheet parameters beyond the tool's general capability. Lacks parameter-specific guidance.

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 lists every embedded image in a local .xlsx file with format, size, sheet attribution, and anchor cell range. It distinguishes itself from siblings like xlsx_read (cell values) and xlsx_charts (charts-as-images).

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?

Explicit USE WHEN (cataloging visual assets, auditing, fingerprinting) and DO NOT USE WHEN (want pixels, need cell values) sections. Provides alternative tool xlsx_read for cell values.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint. The description adds that it is a 'fast orientation call' and that it only works for local files (not uploads). No contradiction with annotations.

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

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

Description is well-structured with clear sections (USE WHEN, DO NOT USE WHEN), but a bit wordy. Could be more concise, but no wasted sentences.

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

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

No output schema, but description lists return fields (names, dimensions, visibility). Covers usage context well. Lacks detail on return format, but acceptable for a simple metadata 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 has 1 parameter (file_b64) with 0% description coverage. The description mentions 'local file path' but the parameter is file_b64 (base64). This mismatch could confuse the agent; the description does not explain how to provide the file content.

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 lists sheet names, dimensions, and visibility for a local .xlsx file. It uses specific verbs and resources, distinguishing it from siblings like xlsx_read, which reads cell content.

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

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

Explicitly provides when-to-use (before xlsx_read for metadata only) and when-not-to-use (file from upload, known structure, or planning immediate xlsx_read). Mentions alternative xlsx_read, making it easy for the agent to decide.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds critical behavioral detail: deliberately does not extract or execute macro source code, uses heuristic UTF-16LE scan, and returns safety advice to relay to the user. No contradiction.

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

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

The description is well-structured into distinct sections (purpose, policy, usage). It is slightly verbose but each sentence adds value. The most critical information is front-loaded.

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

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

Given the tool's complexity and lack of output schema, the description adequately explains the return value (presence, size, module names, safety advice) and limitations. Missing: explicit mention of input format (base64) and potential error cases, but overall sufficient.

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

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

Schema description coverage is 0%. The description does not explicitly explain the 'file_b64' parameter (that it expects a base64-encoded file). The purpose is implied but not clarified, which could lead to incorrect usage.

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

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

The description uses specific verbs ('Inspect', 'Returns') and resources ('xlsm / xlsb workbooks for VBA macro presence'). It clearly distinguishes from sibling tools that analyze other xlsx aspects by focusing solely on macro detection and metadata.

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

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

Provides explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, detailing appropriate scenarios (unknown sender, auditing) and when to avoid (need to inspect VBA source), along with a concrete alternative (open in Excel).

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

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

Annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) are already present. Description adds details about what is returned (master value, range, span, kind heuristic) and notes the free tier cap. No contradiction with annotations.

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

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

Well-structured with problem statement, tool purpose, comparison, usage guidelines, and limitations. Slightly lengthy but front-loaded with key information. No wasted sentences.

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

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

Given no output schema, description explains return fields (value, range, span, kind). Use cases and limitations are covered. Schema has 2 params with clear types. Annotations provide safety cues. Complete for a listing 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 has 2 parameters with 0% coverage. Description does not explain file_b64 or options (limit, sheet) beyond what schema provides. While schema is self-explanatory, description could add context (e.g., file format, how to pass base64). Adequate but missing added value.

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

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

The description clearly states the tool lists merged-cell regions with master-cell value, range, span dimensions, and kind heuristic. It distinguishes from siblings by noting no other tool surfaces merges with master values, and explains the value over pandas and openpyxl.

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?

Explicit USE WHEN (parsing report templates, dashboards, auditing) and DO NOT USE WHEN (if only need cell values, use xlsx_read). Provides clear context and 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true, so no safety concerns. Description adds context about why pandas collapses named ranges and what the tool returns (name, scope, kind, reference), enhancing the agent's understanding of behavior beyond annotations.

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

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

Description is concise and well-structured: a clear first sentence stating purpose, a context note about pandas, and separate USE WHEN/DO NOT USE WHEN sections. Every sentence adds value without redundancy.

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

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

For a simple tool with one parameter and no output schema, the description adequately covers what the tool returns and when to use it. It could optionally mention if the list is sorted or any limitations, but overall it's sufficiently complete for the agent to understand its role.

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

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

Schema has one required parameter 'file_b64' with no description in schema (0% coverage). The description mentions 'LOCAL .xlsx workbook' but does not explain the parameter format (e.g., base64 encoding). With low schema coverage, the description should have compensated but did not, leaving the agent without clear 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?

Description clearly states the verb 'list' and resource 'defined names (named ranges)' in a LOCAL .xlsx workbook, listing the output fields (name, scope, kind, reference). It distinguishes from siblings like xlsx_read and xlsx_formulas by specifying that it surfaces information that pandas.read_excel collapses.

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?

Explicit USE WHEN and DO NOT USE WHEN sections provide clear guidance. It recommends calling before xlsx_read to orient, and warns against use when workbook has no formulas or for upload/attached files. This helps the agent decide when to invoke 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?

Annotations already declare the tool as read-only and idempotent. The description adds aggregation modes, fill_value, and return format (markdown table). However, it does not clarify that file_b64 is base64 content, creating a minor inconsistency with 'LOCAL .xlsx file'.

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

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

The description is concise and well-structured: first a defining sentence, then details, then usage guidelines. Every sentence adds value, and the structure aids readability.

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 a pivot operation and no output schema, the description adequately explains the output (markdown table) and usage context. It distinguishes from xlsx_aggregate but not from other siblings like xlsx_read, which is acceptable due to specific 'USE WHEN'.

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

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

With 0% schema coverage, the description explains most parameters (index, columns, values, agg, fill_value) but omits options.header_row and options.sheet, and only implicitly describes file_b64. Coverage is about 66%, not fully compensating.

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

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

The description clearly states the tool performs a pandas-style pivot_table on a local .xlsx file, reshaping data into a 2D matrix with index, columns, and aggregation. It explicitly distinguishes from groupby operations.

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

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

The description includes explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, providing clear criteria for when to pivot versus using xlsx_aggregate, and noting it is not for upload or attached files.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. Description adds behavioral context such as listing only pre-existing pivot definitions and details returned per pivot (sheet, name, location, source, fields, aggregations). No contradictions.

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

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

Well-structured with clear sections: main purpose, details of output, distinction from sibling, when/not to use. Every sentence adds value. No wasted words.

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

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

Provides detailed information about what data is returned per pivot (sheet, name, location, source, fields, aggregations) and three use cases. Lacks specifics on file type limitations (e.g., .xlsm?) and error handling, but overall sufficient given no output schema.

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 description must compensate. It mentions 'file_b64' implicitly via 'LOCAL .xlsx file' and 'options.sheet' as optional filter. However, it does not explain how to provide the file (e.g., base64 string) or format of options object. Adds some meaning beyond schema but incomplete.

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

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

Clearly states verb 'List' and resource 'PRE-EXISTING pivot table definitions in a LOCAL .xlsx file'. Distinguishes from sibling xlsx_pivot by specifying it lists existing definitions rather than computing fresh ones.

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

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

Explicitly provides when to use: documenting financial models, auditing source ranges, answering aggregation questions. Also provides DO NOT USE cases with specific alternative tool names (xlsx_pivot, xlsx_read).

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

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

Discloses the 3-step upload flow, 10k/month free tier cap, and token handling options (environment vs argument). Annotations already indicate destructive (destructiveHint=true) and non-idempotent, but description adds operational context beyond annotations.

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

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

Purpose is front-loaded, but description is somewhat lengthy with multiple paragraphs. Could be more concise without losing clarity.

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

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

Given 6 parameters, no output schema, and 0% schema coverage, description covers usage and constraints but lacks parameter-level detail. Adequate for basic use but incomplete for nuanced decisions.

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 0% (no parameter descriptions in schema). Description explains 'message' as optional, but does not detail file_b64, filename, workbook_handle, or channel format. Only partially compensates for missing schema descriptions.

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

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

Description clearly states 'upload a local .xlsx file to a Slack channel as a file attachment, with an optional accompanying message', which is a specific verb+resource. Distinct from siblings like xlsx_post_teams.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections with examples ('post this workbook to #channel') and alternatives (reading from Slack is Manual-Mode-Detector pattern). Covers token prerequisites.

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

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

Annotations already indicate destructiveHint=true; description adds token intake options and Graph flow details, but does not elaborate on behavioral traits beyond annotations.

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

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

Four concise sentences front-load purpose, then token info, then usage rules. No wasted words.

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

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

Covers usage and token handling but lacks return value info (no output schema) and parameter details. Adequate for basic guidance but incomplete given 7 parameters.

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

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

Schema description coverage is 0%, yet description provides no per-parameter explanations. Only high-level token handling mentioned, leaving agents unaware of parameter purposes like workbook_handle.

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

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

Description clearly states the tool uploads a local .xlsx file to a Teams channel as an attachment with optional message, distinguishing it from the sibling xlsx_post_slack.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear context, alternatives (Slack), and prerequisites (Graph token).

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating a safe read operation. The description adds behavioral context by detailing what information is returned (print area, orientation, margins, headers, etc.), which goes beyond the annotations.

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

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

The description is well-structured with clear use cases and a brief technical note, but it is somewhat lengthy. Most sentences add value, though a slightly more streamlined version could improve readability without losing essential details.

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

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

Given the complexity of print settings and the absence of an output schema, the description is quite comprehensive about what the tool returns and when to use it. However, the lack of parameter explanations is a notable gap, preventing full completeness for an AI agent.

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

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

The input schema has two parameters (file_b64 and options.sheet) with 0% schema description coverage. The description does not explain the meaning or format of these parameters, such that file_b64 is the base64-encoded file content. It only implies that the tool works on a workbook per worksheet, leaving a significant gap for an AI agent to use correctly.

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

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

The description clearly states the tool's purpose: to surface Excel print settings per worksheet, listing numerous attributes. It distinguishes itself from siblings like xlsx_read by emphasizing that it provides a rolled-up view of print configuration that other tools do not capture.

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

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

The description explicitly states when to use the tool (before PDF/print, audit, extract print-titles) and when not to use it (for reading values, use xlsx_read). It also mentions the free tier cap (10k/mo), providing clear guidance for an AI agent.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds valuable context: the tool reads specific XML files (docProps/core.xml, app.xml, custom.xml) and does not modify data, confirming its read-only nature.

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 clear sections and usage guidance. Some redundancy exists (e.g., repeating 'core' vs specific fields), but overall it is concise 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?

Given the simple parameter and no output schema, the description fully covers purpose, usage, behavioral context, and alternatives. It is self-contained and sufficient for an agent to correctly 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?

The single parameter file_b64 has no schema description (0% coverage). The description only mentions 'from a LOCAL .xlsx file' but does not explain that the parameter is a base64-encoded string, which is critical for correct usage.

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

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

The description clearly states the tool's purpose: to surface the workbook's identity card from a local .xlsx file, listing specific properties and sources. It distinguishes from siblings like xlsx_read and xlsx_redact by specifying when not to use them.

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

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

Explicitly states when to use (auditing, stripping metadata, extracting custom flags) and when not to use (just reading values, modifying metadata), with clear sibling alternatives (xlsx_read, xlsx_redact).

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, openWorldHint=true. The description adds value by explaining the direct OOXML zip reading method (workaround for ExcelJS issues) and clarifying that it does not unlock protection. No contradictions.

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

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

The description is well-structured with clear sections (overview, technical detail, usage guidance). It is reasonably concise for the complexity of the tool, though could be slightly trimmed. The front-loading of purpose is effective.

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

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

Covers workbook-level, per-sheet, per-action, and per-cell protections, and explains the OOXML reading method. Lacks details about return format but this is acceptable without an output schema. Nearly complete for a tool of this complexity.

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

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

Input schema has 2 parameters with 0% description coverage. The description mentions 'local .xlsx file' for file_b64 and implies per-sheet via 'per-sheet', but does not explicitly describe the parameters' types, formats, or optionality (e.g., options.sheet). Since schema provides no descriptions, the tool definition should compensate but falls short.

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

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

The description clearly states the tool's purpose: 'Surface every protection setting in a LOCAL .xlsx file so an agent knows what it can and cannot edit.' It lists specific aspects covered (workbook-level, per-sheet, per-action, per-cell) and distinguishes from sibling xlsx_read by specifying it is for reading values only.

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

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

Provides explicit USE WHEN and DO NOT USE WHEN sections. It advises use before suggesting edits or auditing forms, and warns against using for just reading values (use xlsx_read) or attempting to break protection. This clear guidance helps the agent decide when to invoke.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds critical context: path resolution differences between local and remote deployments, default returns all sheets, format synonyms, and the fact that the server's filesystem is used. No contradictions with annotations.

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

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

The description is well-structured with clear sections and front-loaded key information. However, it is slightly verbose due to detailed path explanations and synonyms. Every sentence adds value, but some redundancy could be trimmed.

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 required 'file_b64' parameter and no output schema, the description is incomplete. It addresses path-based reading but ignores the file_b64 parameter entirely, creating a significant gap. The tool's behavior regarding base64 input is undocumented, which hinders 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?

The description fails to explain the required 'file_b64' parameter (a base64 string) despite focusing on path-based reading. While it partially explains the 'options' sub-parameters (format, sheet), it omits 'maxRows'. With 0% schema description coverage, the description should compensate but does not adequately cover all 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 clearly states the tool reads .xlsx files and returns a markdown/JSON/SQL representation. It effectively distinguishes itself from siblings like xlsx_read_handle by specifying different use cases (path-based vs. handle-based).

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

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

Explicitly provides when-to-use (path on server's filesystem) and when-not-to-use (paperclip upload, remote user files, in-memory bytes). Also notes default behavior of returning all sheets, preventing redundant calls.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, and openWorldHint. The description adds value by noting the dependency on prior upload, handle expiration, and the return shape. No contradiction.

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

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

The description is concise and well-structured: purpose statement followed by usage guidelines. Every sentence adds value, and key information is front-loaded.

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

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

Given the tool's simplicity, read-only nature, and strong annotations, the description covers all essential aspects: what it does, when to use, limitations (handle expiry), and error handling. No output schema needed as return shape is delegated to xlsx_read.

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 description must compensate. It mentions the workbook_handle parameter implicitly and references 'same shape as xlsx_read' for options, but does not explicitly describe the options object's fields or enum values. Adequate but not thorough.

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: read a pre-uploaded workbook using a server-side cache handle without re-transferring bytes. It specifies the return shape matches xlsx_read and distinguishes from the sibling tool xlsx_read, which handles file_b64 transport.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear context for when to use this tool vs. alternatives (e.g., xlsx_read for local files). Also mentions handle expiration and error behavior.

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?

Description discloses critical behavioral traits: embedded attestation in docProps/custom.xml, base64 return, honest declaration boundary (server signs caller-declared agent.name). Annotations already mark readOnlyHint=false and destructiveHint=false; description adds context without contradiction.

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

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

The description is well-structured with clear sections (overview, honesty boundary, usage guidelines). Every sentence adds value, no repetition, and the key information is front-loaded.

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

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

Given 6 parameters, complex nested objects, and no output schema, the description adequately covers the tool's main purpose, return value (_meta.file_b64), and usage contexts. Some parameter details are missing, but the overall intent is clear.

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

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

With 0% schema coverage, description compensates by explaining the agent parameter's honesty boundary and mentioning file_b64 and out_path (though out_path is not in schema). It gives functional context for key parameters but omits details on covers_sheets, inputs, and workbook_handle.

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 attaches an AI-generation cryptographic receipt to an .xlsx file and distinguishes it from sibling tools like xlsx_stamp (for human-authored workbooks) and xlsx_verify_receipt (for verification).

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear guidance on appropriate contexts, with an explicit alternative (xlsx_stamp) and an honesty boundary note.

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

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

The description discloses default behavior (preservation of formulas, comments, etc.), optional stripping parameters, and output handling (out_path vs. base64 return). This adds significant detail beyond annotations, which only indicate idempotent and open-world hints.

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 purpose line, default behavior, output instructions, and usage conditions. It is slightly lengthy but each sentence adds value; minor redundancy in the 'USE WHEN' block.

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

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

The description covers input requirements, default behavior, and output format, but the absence of explanation for 'file_b64' and the erroneous mention of 'out_path' reduce completeness. Without output schema, the description provides adequate but imperfect guidance.

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

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

Schema coverage is 0%, so description is crucial. It explains options (strip_formulas, strip_comments, mode) and output behavior, but it references 'out_path' as a parameter not in the schema, causing confusion. It also fails to describe the required 'file_b64' parameter, leaving a gap.

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

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

The description clearly states the tool redacts PII and sensitive values from LOCAL .xlsx files. The verb 'redact' and resource 'LOCAL .xlsx file' are specific, and it distinguishes from many sibling xlsx tools that perform other operations.

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

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

The description explicitly provides USE WHEN and DO NOT USE WHEN conditions, including file source and sandbox context. However, it does not name an alternative sibling tool for other redaction scenarios, leaving room for improvement.

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

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

Annotations already specify read-only, idempotent, non-destructive. Description adds the critical constraint of local file requirement and reveals output includes confidence levels. No contradiction with annotations.

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

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

Well-structured with purpose sentence, usage hints, and explicit when/not. Front-loaded and mostly concise, though some repetition of 'LOCAL' and the usage section could be tighter.

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

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

Covers purpose, usage, and behavioral constraints well. Lacks parameter format details and a more detailed description of the return structure (though output components are listed). Without output schema, description should provide more specifics.

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

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

Schema has 0% description coverage. Description mentions file_b64 (required) and options (range, sheet) but does not clarify that file_b64 is base64-encoded content, nor does it explain range/sheet format. Meaning added is minimal.

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 infers column schema of local .xlsx files, listing output components (types, nullable flags, header row, sample values, confidence). It distinguishes from siblings like xlsx_read by emphasizing its use before reading data and that it only handles local files.

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

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

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear guidance: use for local file paths before processing, not for uploads/attachments or in-memory data. Also mentions its utility before xlsx_read.

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

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

Annotations already cover idempotent and non-destructive nature. Description adds stateful session-only scope and no-op without session_id. Does not contradict annotations. Could mention if validations are cumulative or replaced, but overall adequate.

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?

Description is three well-structured paragraphs: definition with examples, USE WHEN, DO NOT USE WHEN. Front-loaded with purpose, each sentence earns its place. 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 no output schema, description explains that subsequent calls will use these validations and that it's stateful. It covers the main behavioral context. However, could elaborate on whether validations replace or append, and details of validation rule structure. Still sufficient for most use cases.

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

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

Schema coverage is 0%, so description must compensate. It mentions 'ref', 'sheet', 'type' in examples but does not fully explain these properties or the session_id format. Adds some meaning but not enough detail for a parameter with nested structure.

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

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

The description clearly states it configures per-session data-validation rules with specific examples (reject missing columns, enforce enum values, range-bound numeric). It distinguishes from siblings like xlsx_data_validations and xlsx_validate by emphasizing stateful session-only behavior.

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

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

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide concrete scenarios: multi-step workflows with consistent server-side validation vs. single calls, and requirement of valid session_id. This fully guides the agent on when to select 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?

Beyond annotations (readOnlyHint, etc.), the description discloses that it reads OOXML zip directly and that ExcelJS drops these on round-trip, adding valuable behavioral context.

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

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

The description is concise, well-organized with clear sections, and every sentence adds value without redundancy.

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

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

For a list-type tool with no output schema, the description fully specifies what is listed and how it works, including internal paths, providing complete 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?

Schema coverage is 0% for the single parameter file_b64. The description implies the file is a base64-encoded local .xlsx file but does not explicitly describe the parameter, leaving some ambiguity.

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

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

The description precisely states the tool lists slicers and timelines in an .xlsx file, specifying details like captions, source bindings, and timeline granularity. It distinguishes from siblings like xlsx_read and xlsx_filter.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear guidance on appropriate contexts and alternatives, such as using xlsx_read for values and xlsx_filter for applying filters.

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?

Beyond annotations (readOnly, idempotent), description adds stability across sort keys, type-aware comparison, and nulls sorting last. This enriches understanding of tool behavior beyond safety/cache hints.

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

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

Concise but informative: first line defines core functionality, then behavioral details, then usage guidelines. No wasted words.

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

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

Covers core purpose, usage, and behavioral traits. Lacks details on error handling or file format constraints, but given good annotations and simple nature, it's fairly complete. Mentions return format (markdown table).

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%. Description only explains the 'by' parameter (multi-column, direction) but doesn't clarify 'file_b64' (file input) or 'options' (header_row, limit, sheet). Missing important parameter 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?

Description clearly states it sorts rows of a local .xlsx file with multi-column and per-column direction. It uses specific verb 'sort' and resource 'xlsx file', and distinguishes from siblings by focusing on sorting rather than other data operations.

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

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

Explicit USE WHEN and DO NOT USE WHEN sections with alternative tool (xlsx_read) for cases where data is already sorted or for upload/attached files. Provides clear decision 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?

Description discloses the cryptographic stamping, base64 return, and checks array. Annotations (readOnlyHint=false, destructiveHint=false) are consistent. Minor mismatch: mentions 'out_path' as a parameter but it's absent from the schema. Overall, good behavioral disclosure beyond annotations.

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

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

The description is front-loaded with the main purpose and well-organized (concept, return, parameters, usage). It is slightly verbose but every sentence adds value. Efficient for the tool's complexity.

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 (nested objects, 5 params, no output schema), the description explains the stamp concept and return format but misses details on exclude_sheets, file_b64, workbook_handle, and generated_by. No output schema means return value description ('_meta.file_b64') is insufficient. Partially complete.

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

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

Schema coverage is 0%, so description must compensate. It explains 'checks' well (list of named tests with status) but ignores other parameters: exclude_sheets, file_b64, generated_by, workbook_handle. Also mentions 'out_path' which isn't in schema. Incomplete guidance for most 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 clearly states the tool signs a .xlsx file with a cryptographic integrity stamp, distinguishing it from file-sharing tools like xlsx_post_slack. The verb 'Sign' and resource 'LOCAL .xlsx file' are 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?

Explicit usage guidance is provided with 'USE WHEN' and 'DO NOT USE WHEN' sections, including concrete alternatives (xlsx_post_slack / xlsx_post_teams) and a reference to the verification counterpart xlsx_verify_stamp.

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

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

Annotations declare readOnlyHint, idempotentHint, etc. The description adds significant behavioral detail: default mode is a per-sheet rollup with counts, detailed mode is opt-in and capped at 1000 cells. It explains the value of number formats for interpreting date serials and other formatted numbers. No contradictions with annotations.

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

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

The description is well-structured with three paragraphs: purpose and modes, use cases, usage guidelines. It is front-loaded with the core purpose. Some sentences are redundant (e.g., restating the value of number formats), but overall 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?

Given the tool has 2 parameters (one nested), no output schema, and 0% schema coverage, the description covers the essential context: two modes, cap, use cases, and differentiation from siblings. It lacks explicit description of the return value format, but the mode descriptions provide enough for an agent to understand output shape.

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 explains the 'detailed' and 'limit' parameters by describing default vs detailed modes and the 1000-cell cap. However, it does not explicitly describe 'file_b64' or the 'options' structure, leaving some ambiguity. Overall, it adds meaningful semantics.

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

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

The description clearly states the tool surfaces cell formatting (number formats, fonts, fills, alignment) to reveal how a cell looks, distinguishing it from raw values. It specifies that no other tool provides this fidelity and contrasts with xlsx_read, which only includes basic numFmt hints.

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?

Explicit 'USE WHEN' and 'DO NOT USE WHEN' sections provide clear guidance on when to use this tool (interpreting raw numbers, auditing dashboards, fingerprinting templates) and when to use alternatives (xlsx_read for data only). Also mentions the free tier cap.

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

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

Annotations already declare readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds that the tool works only on LOCAL workbooks and that it enumerates tables that pandas cannot read. This provides meaningful context beyond annotations without contradiction.

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

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

The description is concise with clear sections and front-loaded purpose. The USE WHEN/DO NOT USE WHEN format is helpful. Slight redundancy (e.g., 'pandas cannot see ListObjects' repeats the uniqueness point) but overall well-structured and not overly long.

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, the description mentions returned fields (name, sheet, range, flags, columns) but does not detail the output format or provide examples. Parameter details are missing. For a tool with 2 parameters (one nested) and no output schema, the description should cover these gaps but does not fully do so.

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%, meaning no parameter descriptions in the schema itself. The description does not explain file_b64 (base64 file) or the options parameter (include_columns, sheet). While the tool's purpose implies file_b64, the options are left completely unexplained, which is insufficient 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 verb (list) and resource (Excel ListObjects in a local .xlsx workbook), including specifics like name, sheet, range, and flags. It distinguishes from siblings by noting that pandas cannot see ListObjects, making this the only way to enumerate them.

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

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

Explicit USE WHEN and DO NOT USE WHEN sections provide clear context: use when the user references a named table or needs to discover tables before reading; avoid when there are no Excel Tables or for upload/attached files. This is excellent guidance for tool 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?

Annotations already provide readOnlyHint, destructiveHint, idempotentHint, openWorldHint. The description adds behavioral context like 'one-call' nature, free tier with 10k/month cap, and the broad scope of what it inspects. No contradictions.

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

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

The description is a bit long but well-structured: a concise core statement, a comparative paragraph, and clear use/when-not sections. Every sentence adds value, though the list of returned items could be slightly abbreviated.

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 lists what the tool returns but lacks specifics on the output format (e.g., JSON structure). Given no output schema, this is a gap. However, the tool's purpose and usage are well covered, so it's 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?

Only one parameter (file_b64) with no schema description coverage. The description does not explain the parameter format, but its purpose is inferable from the tool name and context. Baseline 3 given low coverage but simple parameter.

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

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

The description clearly states the tool returns a workbook orientation with a detailed list of components (sheets, dimensions, formulas, etc.) and contrasts with siblings like pandas and openpyxl. It explicitly says 'No other tool can do this', making its unique purpose very clear.

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

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

The description provides explicit USE WHEN and DO NOT USE WHEN sections, giving clear context for when to use this tool (orientation after receiving a workbook, triage, auditing) and alternatives (xlsx_read, xlsx_describe) 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?

The description adds behavioral context beyond annotations by mentioning the two engines, cell-level reports, a free-tier cap of 10k/mo, and that it runs locally. It does not contradict annotations and provides valuable insight into the tool's 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 well-structured and front-loaded with the core purpose. It efficiently uses sections for usage guidelines. While somewhat verbose (e.g., 'No other tool can do this' paragraph), the structure aids readability.

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

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

Given the simple input schema (one parameter) and no output schema, the description covers purpose and usage well but omits details on parameter encoding and return format. Annotations provide some safety context, but the lack of output description leaves completeness lacking.

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

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

The input schema has one parameter (file_b64) with 0% schema description coverage. The description mentions 'LOCAL .xlsx file' but does not explain that the parameter expects base64-encoded file content. This is a significant gap for an agent to correctly invoke the tool.

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 performs a cross-engine consistency check on a local .xlsx file, comparing two independent renderers and reporting cell-level divergences. It distinguishes from siblings by noting that no other tool can do this cross-engine validation.

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 provides 'USE WHEN' (pre-flight check, audit/regression testing) and 'DO NOT USE WHEN' (casual read, use xlsx_read; upload/attached files) sections, giving clear guidance on when to 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?

Annotations already declare readOnly, non-destructive, idempotent. Description adds: excludes nulls by default, include_nulls parameter, returns markdown table, sorted desc with percentage. This goes beyond annotations to specify exact behavior and output format.

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

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

Very concise, front-loaded with core functionality, uses clear sections (USE WHEN, DO NOT USE WHEN). Every sentence adds value, 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?

For a simple value_counts tool, the description covers purpose, usage context, null handling, sort order, output format. No output schema is needed as return value described. Complete for expected use.

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

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

With 0% schema coverage, description partially compensates by mentioning column and include_nulls. However, it does not describe file_b64 (how to supply the file) or options like header_row, sheet, top_n. Users must infer these from parameter names or tool 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?

Clearly states it performs value_counts on one column of a local xlsx file, counts unique values sorted by frequency descending with percentage. Distinguishes from sibling xlsx_aggregate by specifying it's for single-column distribution, not groupby aggregations.

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

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

Explicitly provides USE WHEN conditions (distributions, frequency) and DO NOT USE WHEN cases (groupby aggregations, upload/attached files). Directs to alternative tool xlsx_aggregate for multi-column aggregations.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds valuable behavioral context: three failure modes (no receipt, invalid signature, hash mismatch) and what the tool returns. No contradictions.

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

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

The description is well-structured with clear sections (function, failure modes, usage). It is front-loaded with purpose. Some redundancy exists (e.g., 'verify a workbook's' repeated), but overall efficient for the information conveyed.

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, the description adequately explains return structure (signature valid, hash matches, claims) and usage context. However, it omits parameter details and does not fully list the returned claims, leaving gaps for an agent.

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

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

Schema coverage is 0%, yet the description provides no explanation of the two parameters (file_b64, workbook_handle). An agent cannot determine which to use or their semantics from the description alone. This is a critical gap.

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

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

The description clearly states the tool verifies a workbook's AI-generation receipt, distinguishing it from siblings like xlsx_receipt (generation) and xlsx_verify_stamp. It specifies the exact operation: checking signature, content hash, and returning claims.

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 WHEN' section provides explicit guidance: when a workbook claims AI provenance or for auditing. It also includes a caveat about honesty. No explicit 'when not to use' or alternatives, but sibling differentiation is implied.

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

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

Annotations already indicate read-only and idempotent behavior. Description adds the three verification outcomes and failure modes, providing useful context beyond annotations.

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

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

The description is concise, front-loaded with the primary purpose, and efficiently organized with a list of failure modes and a usage section.

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

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

The description covers the return values, failure modes, and when to use the tool. It lacks explicit mention of prerequisites (e.g., workbook must have a stamp) but is otherwise complete for a verification 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%, but the description does not explain the two parameters (file_b64, workbook_handle). The agent must infer their usage, which is insufficient given the lack of schema descriptions.

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

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

The description clearly states the tool verifies an integrity stamp and details the three failure modes, distinguishing it from sibling tools like xlsx_verify_receipt by focusing on stamps.

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 WHEN' section provides explicit scenarios for using the tool, but does not exclude cases where other verification tools (e.g., xlsx_verify_receipt) might be more appropriate.

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

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

Annotations already indicate readOnlyHint and idempotentHint. The description adds significant context by detailing exactly what data is returned (visibility, view state, zoom, active cell, frozen panes, etc.), which goes beyond the annotations and fully informs the agent of tool 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 well-structured with a clear front-loaded purpose, followed by details and usage guidance. Every sentence adds value, and there is no redundancy or filler. It is appropriately sized for the information provided.

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

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

Given the lack of output schema and low schema coverage, the description provides thorough information about what the tool returns, including specific fields and usage scenarios. It covers both behavior and context, making it complete for a read-only inspection 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 should compensate by explaining parameters. While it implies file_b64 is the file and options.sheet may filter, it does not explicitly define their meaning or format. The description mentions 'per sheet' but lacks a direct mapping to parameters, making it only partially adequate.

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 surfaces the UI state of a local .xlsx file, listing per-sheet and workbook-level details. It explicitly distinguishes from sibling tools like xlsx_read for reading values, making the purpose unambiguous.

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

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

The description provides explicit 'USE WHEN' and 'DO NOT USE WHEN' sections, specifying scenarios like resuming editing or auditing hidden sheets, and directing to xlsx_read for value reading. This provides clear decision 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?

Annotations indicate readOnlyHint=false (confirming write intent) and destructiveHint=false. The description adds behavioral context: server-side validation before writing, fallback to _meta.file_b64 when no out_path given, and the requirement to pass out_path for disk save. This enhances agent understanding beyond annotations. A minor deduction for not clarifying whether an existing file is overwritten or updated.

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 somewhat lengthy but well-structured: purpose, spec shape, example, output behavior, and usage guidance. The example is helpful but could be shortened. The mention of 'out_path' not in schema adds unnecessary complexity. It's informative but not maximally concise.

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

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

Given the tool's complexity (nested spec, optional base_file, output via b64 or file), the description covers creation/update, spec details, and output modes. However, the omission of base_file_b64 explanation and the inclusion of out_path (not a parameter) leaves gaps. The lack of output schema is partially mitigated by noting _meta.file_b64. Overall, adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It describes the 'spec' parameter well (shape, example, constraints) but mentions 'out_path' which is NOT in the input schema (the schema only has spec and base_file_b64). This mismatch creates confusion about required/optional parameters. The base_file_b64 parameter is not explained at all. Overall, the description adds some value for spec but fails to fully cover both parameters, and introduces an undocumented parameter.

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

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

The description begins with a clear verb+resource phrase: 'create or update a LOCAL .xlsx file from a structured spec.' This immediately distinguishes the tool from sibling tools like xlsx_read, xlsx_convert, etc., which handle other operations. The purpose 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 explicitly provides 'USE WHEN' and 'DO NOT USE WHEN' conditions, giving direct guidance on appropriate contexts and exclusions. It also compares to alternatives (safer than generating xlsx bytes directly), helping the agent decide when to invoke this tool over others.

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