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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers: it discloses all-or-nothing failure semantics, the byte-for-byte unchanged guarantee, backup slot behavior, verify-after-write restoring from backup, formula recalculation flags, the 200,000-cell ceiling per write_range, refuse conditions (hazardous workbook, open in Excel), and the return values (counts of edits and cells touched).

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 information-dense but tightly packed—every sentence covers a distinct behavioral trait (validate-before-write, backup, verify-after-write, formula normalization, limits, refuse conditions). It front-loads the core purpose and op shapes before diving into atomicity details. It is longer than a typical tool description, but the density justifies the length; a small amount of trimming or structural breakdown (e.g., bullet separators for each op) could improve scannability.

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

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

Given 5 parameters, no annotations, no per-parameter schema descriptions, and an output schema hint, the description covers the most complex behaviors and return expectations. Gaps remain: it doesn't explicitly explain what 'verify_com' controls, whether the backup parameter can be disabled, or the exact output schema fields; because the tool is a complex mutation, the description could be complete only with a bit more detail on those structured fields.

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

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

Schema description coverage is 0%, so the description must compensate for the sparse schema. It explains the structure of 'edits' with concrete op examples and payload shapes (set_value {value}, set_formula {formula}, clear {what}, write_range {data: 2D array}), and it explains the behavior of allow_loss, backup, and verify-related conditions implicitly. It doesn't explicitly define every parameter (path, verify_com), but it adds substantial meaning to the most complex one.

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

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

The description opens with a precise verb phrase—'Apply many addressed edits as ONE atomic batch'—and then enumerates the exact op shapes (set_value, set_formula, clear, write_range) with their payloads. This makes the tool's resource and action unmistakable, and the atomic-batch qualifier differentiates it from single-edit siblings like set_cell, set_cells, and write_range.

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

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

The description implies the tool is for batching multiple edits atomically and contrasts with the hazardous-workbook/open-in-Excel preconditions, which is useful context. However, it never explicitly names an alternative like set_cells or write_range or says 'use this when you need atomicity, use set_cells for one-off writes,' so the when-to-use guidance is strong but not fully explicit.

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

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

With no annotations provided, the description carries the full disclosure burden, and it delivers richly: it declares read-only safety, states it 'works while the file is open in Excel' (concurrency behavior), and reveals the truncation mechanism ('capped with exact counts and a truncated flag'). It also exposes a subtle semantic gotcha — missing_cached_values cells 'read as blank to every non-Excel consumer until a recalculation' — which is exactly the kind of non-obvious behavior an agent needs to know.

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

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

The purpose and scope are front-loaded in the first sentence, followed by a functional per-report breakdown that an agent needs to interpret results. At roughly 140 words it is longer than average, but every sentence earns its place — the report details, truncation behavior, usage window, and safety note are all decision-relevant. A slight trim of the per-report prose would make it tighter, but nothing is wasted.

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

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

The description is remarkably complete for a complex tool with zero annotations and zero schema descriptions: it covers scope selection, all five report semantics, truncation limits, concurrency, read-only safety, and practical usage timing, while the output schema handles return-value structure. The remaining gap is the ambiguous interaction of sheet and location parameters together, and the absence of explicit parameter-name mapping — minor issues given how much is already covered.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: the opening line maps the three scope modes onto the parameter combination — 'a range' (location), 'one sheet (sheet alone)' (sheet), 'whole workbook (no scope)' (neither). This is essential meaning the schema entirely lacks. It loses one point because the description never explicitly names parameters or defines how location and sheet interact when both are supplied.

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

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

The description opens with a specific verb and resource: 'Read-only formula intelligence for a range, one sheet, or the whole workbook,' then names the exact deliverable ('the formula list plus five safety reports'). It distinguishes itself from siblings like read_range (value reading), set_formula (writing formulas), and diagnose_workbook (general diagnostics) by pinning down formula-specific auditing across three explicit scope modes.

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

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

The description gives concrete usage timing: 'Use it before and after structural edits, and to judge whether cached values can be trusted.' This is clear contextual guidance for when to invoke the tool. It stops short of a 5 because it never names alternatives or states when not to use it (e.g., comparing against diagnose_workbook or validate as siblings).

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

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

With no annotations provided, the description carries full responsibility and does an excellent job. It discloses error behavior (NOT_FOUND), side effects (unhides rows), return value (number of unhidden rows), safety behavior (hazardous workbook refusal, allow_loss), backup behavior, atomic save, and the Excel lock refusal.

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?

Every sentence carries essential operational information. The core action is front-loaded, and the supporting details about selection, refusals, return values, backup, and Excel lock are compact and non-redundant.

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

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

For a tool with no annotations and 0% schema description coverage, this description is notably complete. It covers the operation, parameter semantics, failure modes, safety requirements, return behavior, and environmental constraints. The output schema exists, so the return type is already structurally defined.

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 location/sheet selection semantics, the default use of the active autofilter range, and the meaning of allow_loss. It does not explain verify_com or path in detail, but it adds substantial meaning beyond the schema for several parameters.

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

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

The description states the specific action: removing the autofilter from a sheet and unhiding rows, which clearly identifies the resource and behavior. It also names itself as the reverse of set_filter, distinguishing it from the most relevant sibling tool.

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

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

The description explicitly positions the tool as the reverse of set_filter, tells how sheet selection works, warns that a sheet without an autofilter refuses rather than no-oping, and specifies when allow_loss is needed. This gives agents clear when-to-use and when-not-to-use guidance.

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

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

With no annotations, the description carries the full behavioral burden, and it delivers thoroughly: it explains destructive scope, hazardous workbook refusal, allow_loss requirements, auto-backup behavior with rotation, atomic verified saves, restore on failed verification, and refusal while open in Excel.

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 dense but every sentence adds essential information. It front-loads the core operation and then efficiently covers exclusions, hazards, backup behavior, and lock conditions 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 destructive nature and the absence of annotations, the description is remarkably complete. It covers what gets cleared, what persists, safety guards, backup semantics, failure recovery, and environment restrictions. An output schema exists, so return-value documentation is not required here.

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 'what', 'backup', 'allow_loss', and 'location' parameters meaningfully. However, 'path', 'sheet', and especially 'verify_com' are not explained, leaving some parameters underspecified.

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 clears a cell or range and precisely defines the three 'what' modes: contents, formats, and all. It also distinguishes what the tool does not remove, eliminating ambiguity about scope.

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

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

The description gives practical usage context: it clarifies that merges, conditional formats, validations, comments, and hyperlinks are not handled here and have their own manage tools. It also states important refusal conditions, but it does not explicitly name sibling alternatives or contrast with related tools like write_range or set_cell.

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

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

With no annotations provided, the description carries the full behavioral burden and does so excellently: the destination is overwritten, the source is buffered so overlapping pastes are safe, relative formulas shift while absolute anchors stay, hazardous workbooks are refused unless allow_loss is true, auto-backup occurs, saves are atomic and verified, and the tool refuses while the workbook is open in Excel.

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 dense but efficient, with each clause adding a meaningful behavioral constraint. It is front-loaded with the core operation and then lists edge cases. The grammar is a bit fragmented, especially the 'what is' clause, but it remains compact and scannable.

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

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

For a 9-parameter tool with no annotations and zero schema descriptions, the description covers the major behavioral concerns: overlap safety, formula adjustment, data-loss protection, backups, atomic saves, and Excel-lock refusal. It falls short only on a few parameter details like verify_com, sheet, and explicit path/location-object shape, though an output schema exists to describe return values.

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

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

Schema description coverage is 0%, so the description must add parameter meaning. It explains what values for 'what', location objects for source/dest, allow_loss, adjust_formulas, and backup behavior. However, it does not explain verify_com, sheet, or the exact structure of location 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 opens with a specific verb and resource: 'Copy a source rectangle to a destination anchor.' It clearly distinguishes this from siblings like move_range, write_range, and copy_workbook by describing the exact object being copied and the destination concept.

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

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

The description gives no explicit guidance on when to use copy_range versus alternatives such as move_range, write_range, or copy_workbook. It explains mechanics and safety behavior but never states the intended selection conditions or when another tool should be preferred.

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

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

With no annotations provided, the description carries the full burden and does an excellent job: byte-for-byte copy, overwrite behavior, backup rotation into .ks4xl-backups prev, restore path, and return value are all disclosed. This goes well beyond what the schema or annotations reveal.

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

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

The description is compact but information-dense, front-loading the core operation before explaining overwrite and backup behavior. Every sentence contributes meaning and none is wasted.

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 3-parameter utility with a stated output, the description covers the operation, edge cases, backup behavior, restoration path, and intended usage. Even with an output schema present, it still clarifies the return value. No significant invocation-relevant gap remains.

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 define the parameters, and it does: src and dst are the source/destination paths, and overwrite's default and side effects are fully explained. No crucial parameter meaning is left to the agent to infer.

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

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

The description states a specific verb and resource: copy a workbook file byte-for-byte from src to dst. It also clarifies the unique value proposition (no re-serialization, charts/shapes/macros carry over), which clearly distinguishes it from sibling tools like copy_range or create_workbook.

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

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

It explicitly recommends a use case: branch a working copy before a risky batch of edits. However, it does not name alternative tools or state when not to use it, so it lacks the full when/when-not/alternatives specificity of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure and does so thoroughly: header deduplication, style and banding toggles, totals mapping, refusal on overlap or name conflict, hazardous-workbook protection, auto-backup, atomic verified save, and refusal while the file is open in Excel. This gives an agent realistic expectations for side effects and failures.

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 dense but efficient, front-loading the core purpose before detailing options and constraints. Every sentence adds useful information, and there is no filler or repetition.

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

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

Despite strong behavioral coverage, the tool has 13 parameters and zero schema-level descriptions, so the missing parameter explanations for path, location, sheet, totals_row, and verify_com leave the description incomplete for fully correct invocation. The presence of an output schema helps, but it does not compensate for the parameter ambiguity.

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

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

The description adds real meaning for several parameters: name, header, style, row_stripes, col_stripes, totals, and allow_loss. However, with 0% schema description coverage, it omits important parameters such as path, location, sheet, totals_row, and verify_com; notably, location has an empty schema type, so the agent must infer that it is the range being converted.

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

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

The description opens with a specific verb and resource: 'Turn a range into an Excel table (ListObject) named name.' This clearly distinguishes create_table from sibling tools like get_table, read_range, or write_range while also stating the key result.

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

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

The description gives no guidance on when to use this tool versus alternatives such as import_data, write_range, or get_table. It explains refusal conditions and behaviors, but not when an agent should select create_table over sibling tools.

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

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

With no annotations present, the description carries the full burden, and it delivers: it discloses overwrite behavior, backup rotation into .ks4xl-backups, restore via source='prev', and the fact that an existing file is untouched unless overwrite is true. It also explains important edge-case constraints like sheet name length and apostrophe restrictions.

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

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

The description is compact yet information-dense, with no filler. Every sentence adds meaningful detail: creation action, sheet constraints, overwrite/backup semantics, and return value. The primary purpose is front-loaded, and supporting edge cases follow logically.

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

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

Given the tool's moderate complexity and zero annotations, the description is impressively complete. It covers purpose, prerequisites, constraints, overwrite behavior, backup/restore implications, and the return value. An agent has everything needed to invoke this tool correctly without additional research.

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

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

Schema coverage is 0%, so the description must explain all parameters, and it does. It covers path, sheets (including default 'Sheet1' and uniqueness/length constraints), and overwrite (including its backup-rotation side effect). This fully compensates for 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 opens with a specific verb and resource: 'Create a new .xlsx workbook at path' with given sheet names. It clearly distinguishes this from sibling tools like copy_workbook or get_workbook_metadata by focusing on creation and including unique creation constraints.

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

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

The description provides clear context for when to use the tool: creating a new workbook at a specified path, with prerequisites like the parent directory already existing. It does not explicitly name alternative sibling tools, but the creation-specific scope makes the intended usage clear.

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

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

With no annotations, the description carries the full behavioral burden and delivers: read-only operation, hazards never block reads, refusal behavior for mutating tools unless routed through Excel or allow_loss:true, and an honest limitation about the extLst top-level walk. This is exemplary disclosure.

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

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

The description is long but every sentence carries meaningful operational guidance; it front-loads the verdict and then structures the decision flow, coverage details, and limitations. The verbosity is justified by the complexity of the scan behavior.

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

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

It covers what the scan reports, the decision rules for mutating tools, the allow_loss escape hatch, coverage of x14 conditional formats, and the extLst limitation. With an output schema already present to document return values, nothing essential is missing.

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

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

The schema has a single required `path` string with zero description coverage, and the description never explains path format, what the workbook path refers to, or any constraints. Although the parameter name is self-explanatory, the description does not compensate for the missing schema documentation as required.

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

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

The description states a clear purpose: a round-trip hazard scan that reports which fragile workbook parts exist, whether an openpyxl edit would drop them, and a routing recommendation. It positions the tool as the safety check before mutation, which distinguishes it clearly from sibling tools that mutate or read data.

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

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

It explicitly tells the agent to run this check before mutating a workbook and explains what clean versus would-lose verdicts mean for whether mutating tools will refuse. It does not name alternative diagnostics like validate, but the timing and decision logic are strong.

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

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

With no annotations, the description carries full disclosure responsibility, and it does so thoroughly. It discloses idempotency, that the lite core is never disabled, that the result reports disabled packs/token savings/remaining surface, and the failure behavior when a disabled tool is invoked or the host locks the surface.

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 information-dense but every clause earns its place. It front-loads the primary action, then adds idempotency, result contents, parameter semantics, recovery behavior, and policy constraints without redundancy or filler.

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

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

For a tool with one parameter and a non-trivial interaction with enable_tools, the description is complete. It covers valid inputs, side effects, return relevance, policy refusal, and the non-dead-end behavior after disabling a pack; the presence of an output schema means return-value details do not need to be repeated.

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

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

The input schema only says packs is a required array of strings with 0% description coverage, so the description must supply the meaning. It does: packs accepts the same names as enable_tools or ['everything'], and it directs the agent to enable_tools' description for the actual menu. This fully compensates for the bare schema.

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

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

The description states a specific verb and resource: 'Disable previously enabled tool packs for this session and reclaim their context.' It also distinguishes behavior from enable_tools by noting the lite core stays on and that pack names match enable_tools, so an agent can tell exactly what this tool does.

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

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

The description gives clear operational guidance: it can disable packs by name or ['everything'], it is idempotent, it refuses under KS4XL_PACK_POLICY=locked, and it explains what happens if a tool from a disabled pack is called. It explicitly points to enable_tools for the pack menu and recovery path, covering both when and how to use the tool.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it discloses idempotency, token reporting, policy-based refusal, and per-pack token costs. For the com pack it explicitly states that it drives a private hidden Excel instance and never touches the open Excel session, which is critical safety-relevant behavior. There is no contradiction with annotations because none are present.

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

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

The description is long but every part earns its place: a core behavior sentence, a refusal condition, a task map, and structured pack details. It is front-loaded with the main behavior before diving into the pack catalog, and none of it merely repeats schema information.

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

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

For a tool with one unconstrained array parameter and no enums, the description supplies the complete vocabulary of valid values, their meanings, their costs, and their behavioral implications. It also covers reversibility, policy limitations, and side-effect isolation. Since an output schema exists, the description does not need to detail the return payload, so nothing essential is missing.

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

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

The input schema only declares an array of strings with 0% description coverage, so the description must define the valid values—and it does by naming design, io, com, and ['everything']. It goes further by enumerating the exact features enabled by each pack, which the schema alone would never convey. This fully compensates for the schema gap.

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

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

The description states a specific verb and resource: enabling optional tool packs mid-session, and immediately explains that sessions start lite, which makes the tool's role concrete. It also distinguishes itself from the sibling disable_tools by naming the reverse operation, and the pack/task mapping makes the scope explicit.

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

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

The description explicitly says when to use the tool (mid-session, after a lite start) and names disable_tools as the reversal alternative. It also gives a clear exclusion condition by stating it refuses under KS4XL_PACK_POLICY=locked. The task map tells an agent which pack to select for specific feature groups, providing strong routing guidance.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly: it discloses the read-only guarantee ('the workbook never changes'), target safety guards (never source workbook, extensions, or backups), overwrite refusal with a timestamped .bak side-effect, and the fact that the result reports the values mode used. This is exemplary behavioral disclosure beyond name and schema.

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

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

Four dense sentences, front-loaded with the core purpose. Every clause earns its place by adding a distinct behavior, constraint, or alternative reference; there is no filler or repetition of obvious facts.

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 9-parameter tool with no annotations, the description provides all key guard rails (target protections, overwrite semantics, read-only behavior) and output mode details, and an output schema exists to cover return shape. Minor ambiguity remains around what path refers to precisely and the effect of header/records, but nothing blocks a correct first call.

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 non-obvious parameters well: location's default ('sheet's true used range' and '{table}'), the values enum ('cached | formula | both'), out_file's inline-versus-file behavior, and overwrite's backup side-effect. However, header, records, path, and sheet receive little or no parameter-level elaboration, keeping it just short of 5.

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

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

States the specific verb 'export', the exact resource ('a range, table, or sheet'), and the target formats (CSV, TSV, JSON). It clearly differentiates from the mostly read/write/format siblings and even mentions export_file as the multi-sheet counterpart.

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 directs multi-sheet exports to the alternative ('Multi-sheet export is export_file (io pack)'), giving a condition that routes the agent. It also clarifies when output returns inline versus to a file, though it does not enumerate all contexts where this tool should not be used.

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

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

With no annotations, the description fully carries behavioral disclosure. It clearly states the tool is read-only, works while the file is open in Excel, returns every match with addresses, describes match semantics (exact/contains/regex), explains look_in values/formulas/both, reveals that formula cells use the last cached value, and mentions timeout guarding for pathological regex patterns. This is unusually thorough.

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

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

The description is dense but every sentence adds value: search scope, result behavior, match/look_in semantics, formula caching, pagination, and read-only/open-file behavior. The only slightly opaque phrase is 'plural sibling of the single-target search location selector,' but it still earns its place by signaling the tool's relationship to a sibling.

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 core search behavior, accepted match modes, look_in choices, formula-cell nuance, pagination, read-only safety, and file-open compatibility, which is strong given no annotations. An output schema exists, so return-value details need not be repeated. However, the location parameter and match_case behavior are not clearly explained, leaving a small gap for fully correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains match, look_in, limit, offset, and the timeout behavior, and clarifies how formula cells are searched. However, it does not meaningfully explain path, sheet, location, or match_case, leaving some parameter semantics to inference despite the 0% schema coverage.

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

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

The description opens with a specific verb and resource: 'Search cell values and/or formulas across a workbook, sheet, or range' and clearly states the return behavior: 'return EVERY match with its unambiguous address.' It also distinguishes itself from a single-target search alternative via the 'plural sibling' note, making its purpose easy to identify among many sibling tools.

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

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

The description implies the intended use case: searching for multiple matches across a workbook/sheet/range, and notes the tool is read-only and works while the file is open. However, it does not explicitly state when to prefer this tool over siblings like get_cells, read_range, or query_range, nor does it name alternatives or exclusions.

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

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

With no annotations present, the description carries the full burden, and it delivers meaningful behavioral detail: unspecified attributes are preserved, operations are hazard-gated with an allow_loss override, auto-backup occurs, saves are atomic and verified, and the tool refuses to run while the file is open in Excel. This goes well beyond a bare mutating-tool description and gives an agent accurate risk expectations.

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 dense but well organized: purpose first, then parameter object shapes, then safety behavior. Every sentence earns its place and the semicolon-separated style catalog avoids 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 complex 11-parameter formatting tool with zero schema descriptions and zero annotations, the description covers the core operation, all style object grammar, and critical safety semantics. It is slightly incomplete on positional parameters and the meaning of verify_com, but an output schema exists and the 'design pack' remark clarifies scope limitations.

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

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

Schema description coverage is 0%, so the description must explain parameter meaning, and it does for the key style objects: number_format, font, fill, border, alignment, and color format. It also touches allow_loss ('Hazard-gated') and backup ('auto-backup'), though path, sheet, location, and verify_com are left to general tool-context inference.

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

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

The description opens with a specific verb and resource ('Apply formatting to a range') and distinguishes the operation from value-writing siblings by explaining that it merges formatting onto existing styles. It also enumerates exactly which formatting dimensions are covered, so an agent can tell this apart from set_cells/write_range.

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

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

The primary use case is implied by the verb 'Apply formatting' and the detailed style parameter semantics, and the phrase 'Named styles and conditional formats: design pack' hints at an exclusion for those features. However, there is no explicit when-to-use or when-not-to-use statement, and no alternative sibling is named for comparison.

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

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

With no annotations, the description carries full disclosure responsibility. It states read-only behavior, works while the file is open in Excel, enforces a 1,000-cell ceiling, and explains the honest value-labeling semantics so formulas without cached values are not misrepresented as blank. This is rich, non-obvious 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 dense but every clause earns its place: the primary action, the contrast with read_range, parameter semantics, limits, labeling behavior, and runtime constraints. It is front-loaded and free of filler.

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

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

For a read tool with moderate complexity and no annotations, the description covers the key operational constraints: cell addressing, ceiling, value modes, honest labels, read-only safety, and Excel-open compatibility. The output schema exists, so return-value structure does not need to be described.

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 cells parameter format (A1 strings or location objects, each resolving to one cell) and the values parameter options (cached, formula, or both). It does not explicitly describe path or sheet, but those are relatively self-explanatory from the schema names and sibling 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 states a specific verb (Read) and resource (many individually addressed cells), and immediately differentiates itself from read_range as the scatter complement to its rectangular counterpart. The phrasing leaves no ambiguity about what the tool does.

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

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

It explicitly names read_range as the rectangular alternative and implies this tool is for reading non-contiguous cells. It does not enumerate all other sibling tools, but the scatter-vs-rectangle contrast provides clear decision context for the primary 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?

With no annotations provided, the description fully carries the behavioral burden and does so admirably. It discloses read-only behavior, cached vs formula value modes, pagination caps, truncated flags, merged-cell handling, anchors, and STALE_ANCHOR failure semantics.

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 dense but every sentence adds value, and the main purpose is front-loaded. It is organized into clear thematic chunks: output shape, location/values behavior, pagination, anchors, and a pairing suggestion.

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 both the input semantics and the output structure, including details like formula markers, merged ranges, truncation flags, and the anchor token. Despite an output schema existing, the description still adds necessary context and leaves little for an agent to guess.

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

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

Schema description coverage is 0%, so the description must explain parameters, and it does. It explains location defaults to the used range, values modes ('cached' vs 'formula'), and max_rows/max_cols pagination caps. The meaning of path and sheet is self-evident from names and types.

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

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

The description states a specific verb and resource: a compact, token-efficient projection of a sheet or range. It clearly distinguishes itself from a per-cell JSON dump and names its output components, so an agent can tell it apart from read_range or get_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?

The description gives clear context: use it to see the grid compactly, read-only, and while the file is open in Excel. It also suggests pairing with apply_edits for editing, but it does not explicitly state when to choose this over alternatives like read_range or get_cells.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It clearly labels the call as read-only, states that it needs no workbook, touches no file, and contains no side effects. This is exactly the kind of context an agent needs beyond the schema.

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

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

The description is two sentences with no filler. The first sentence front-loads the exact report contents, and the second gives usage context and a decision hook. Every phrase adds value.

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

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

For a zero-parameter read-only tool with an output schema, the description covers everything needed: what is reported, that it is safe and side-effect-free, when to call it, and how to use the results to decide on enable_tools. Nothing important is missing.

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

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

The tool takes zero parameters and the schema has no properties, so there are no parameter semantics to document. The description correctly focuses on what the tool reports. A baseline of 4 is appropriate for a zero-parameter 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 opens with a specific verb, 'Report', and a concrete resource: the KitchenSink4XL server build, including version, enabled tool surface, optional packs, platform, and Python. This clearly differentiates it from the many workbook-centric sibling tools, especially since it explicitly states no workbook is needed.

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

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

It explicitly tells the agent when to use the tool: to confirm the server is reachable and to inspect loaded packs before deciding whether to call enable_tools. It also states what it is not for operationally ('needs no workbook and touches no file'), which helps route away from workbook tools.

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

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

With no annotations, the description carries the behavioral burden, and it delivers: it states 'Read-only; nothing is written,' explains the cached/formula/both value semantics, and describes the return shape (table ref, column names, data rows, no header/totals row). It does not discuss auth or rate limits, but for a read tool this is strong behavioral disclosure.

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

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

The description is dense but every sentence earns its place: purpose, parameter semantics, return behavior, and alternatives are all packed into a few sentences. It is front-loaded with the core action and contains no filler.

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

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

Given the 5-parameter input schema and the presence of an output schema, the description is largely complete. It covers the main options, return behavior, and alternatives. The only notable omission is the meaning of the required 'path' parameter, and there is no explicit example, but overall an agent can invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains name, columns, values, and records clearly. The only gap is the 'path' parameter, which is required but never described; still, most parameters are given meaningful semantics beyond the raw schema.

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

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

The description opens with a specific verb and resource: 'Read a table's data by its name.' It immediately clarifies case-insensitivity and then contrasts with related operations by naming query_range for paging and manage_table for advanced ops, so an agent can distinguish it from siblings without opening schemas.

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 routing guidance: use query_range with a {table} location to filter or page big tables, and use manage_table for advanced table operations. This gives clear when-to-use and when-to-use-alternative signals.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states read-only behavior, that it does not open the file for edit, that it works while the file is open in Excel, and even explains the nuance of TRUE used ranges versus stored dimensions and the round-trip hazard summary. This is rich, accurate 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?

Despite being detailed, the description is efficiently packed: it front-loads the core purpose ('Read a workbook's structure without opening it for edit'), then lists return contents in a compact, scannable way, and closes with the key read-only and Excel-open caveats. Every sentence adds value; none is redundant.

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 fully covers what the tool does, when to use it, what it returns, and important behavioral caveats. An output schema exists, so return-value details do not need to be repeated. For a single-parameter read-only tool, the description is complete enough for an agent to select and invoke it correctly.

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

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

The only parameter is 'path', and the schema provides no description of it. The tool description implies the path points to a workbook but does not explicitly explain path format, file type requirements, or accessibility expectations. Since schema description coverage is 0%, the description should compensate more, though the single parameter is relatively self-evident.

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

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

The description states a specific action (read) and a specific resource (a workbook's structure), then enumerates exactly what is returned: sheets, visibility, used ranges, dimensions, merged-cell counts, defined names, tables, active sheet, and round-trip hazard. It clearly differentiates itself from editing-oriented siblings by calling itself 'the orient-before-editing call' and read-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?

The description explicitly says when to use it: before editing, as an orientation step, and notes it works even while the file is open in Excel. It also implies when not to use it: when you want to modify the workbook rather than read it. It does not name a specific alternative sibling, but the usage context is clear enough.

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

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

With no annotations, the description fully carries the behavioral disclosure burden. It states 'Pure guidance: reads nothing, changes nothing,' and also discloses that unshipped COM-tier tools are marked as forthcoming rather than falsely presented. This is exemplary transparency.

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

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

The description is compact yet information-dense, front-loading the core purpose before call patterns, caveats, and safety. Every sentence adds value; no filler or redundancy.

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

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

For a guidance tool with an output schema, the description provides everything an agent needs: what it returns, how to invoke it, what tasks exist, how incomplete tools are handled, and that it has no side effects. Nothing important is missing.

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

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

Schema coverage is 0%, so the description must explain the task parameter, and it does so thoroughly: null means list available tasks, a string names the specific task, and the valid task names are enumerated. This fully compensates for the schema's lack of 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 identifies a specific purpose: returning recommended tool sequences for common multi-step spreadsheet tasks. It lists the exact available tasks and explicitly disclaims any data access, distinguishing it from the many spreadsheet-mutation siblings.

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

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

The description gives explicit call conventions: call with no task to list tasks, call with task='<name>' for the recipe. It does not explicitly contrast with alternatives like validate or diagnose_workbook, but the context of 'pure guidance' makes the intended use clear.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It does an unusually good job: formula-injection blocking, the 200,000-cell write ceiling, hazardous-workbook refusal, auto-backup, atomic verified save, and refusal while the workbook is open in Excel are all disclosed. The main gap is that it does not state whether existing cells in the destination range are overwritten or how 'hazardous' is defined.

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 dense but every sentence carries distinct, non-obvious information. Purpose is front-loaded, and the safety and failure behaviors are listed without redundant filler.

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

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

The tool has 13 parameters and no annotations, so the description needs to be far more complete. It leaves the required path unexplained and omits enough parameters (header, encoding, delimiter, verify_com, sheet) that an agent could not reliably construct a correct non-default call. The presence of an output schema does not offset these input-side gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains source/source_file, fmt auto-detection, location, formulas, allow_loss, and backup. However, it does not explain the required 'path' parameter at all, and it omits sheet, header, encoding, delimiter, and verify_com, leaving several parameters ambiguous for a non-default call.

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

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

The description opens with a specific verb and resource: 'Import CSV, TSV, or JSON into a sheet at an anchor.' It clearly conveys the tool's file-import purpose and formats. It does not explicitly distinguish itself from sibling write/export tools, but the format and anchor context make the distinction reasonably 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 gives practical input-mode guidance (source vs source_file), anchor default, and several failure/refusal conditions. However, it does not explicitly state when to choose this tool over alternatives such as write_range, set_cells, or export_range; the usage context is implied rather than explicitly scoped.

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

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

There are no annotations, so the description bears full responsibility for behavioral disclosure. It thoroughly covers destructive semantics: restore rotates current content into prev first so it is undoable, validates the payload, uses atomic replacement, and refuses when files are open in Excel. It also explains dry_run defaults to TRUE and that snapshots are never rotated.

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

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

The description is long but dense and well-structured. Each sentence earns its place by defining an action, a parameter, or a safety behavior. It opens with the core resource and slot model, then enumerates actions in consistent action='x' format, and closes with the limitation and recovery pointer. Nothing feels like filler.

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

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

For an eight-parameter tool with no annotations and no schema-level descriptions, the description is remarkably complete. It covers rotation semantics, restore undo behavior, Excel-open refusal, dry_run behavior, snapshot permanence, the limitation of prev, and the recovery alternative. Since an output schema exists, failing to describe return values is acceptable.

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 fully. It does: action values are defined, path versus directory is distinguished, source is constrained to prev/anchor, scope is constrained to orphans/slots, dry_run's default and meaning are stated, and label/dest_dir are explained for snapshots. Every parameter receives 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 names a specific resource (the hidden .ks4xl-backups folder) and enumerates four concrete actions: list, restore, purge, and snapshot. It also explains the two rotating slot types, prev and anchor, so an agent understands exactly what the tool manages and how it differs from ordinary workbook 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 gives explicit action-specific usage: list takes a path or directory, restore requires source prev/anchor and refuses open Excel files, purge accepts scopes orphans/slots, and snapshot creates permanent copies. It also names the alternative for lost/corrupt files: get_workflows task='recover-workbook'. This gives an agent clear conditions for selection.

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

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

With no annotations, the description carries the full burden and does so thoroughly: it discloses that add overwrites the cell value, remove preserves text/style, list catches both real links and HYPERLINK() formulas, mutating actions auto-backup and use atomic verified save, and hazardous workbooks require allow_loss.

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 dense but well organized: actions are front-loaded, each sentence adds a distinct behavioral fact, and safety constraints are grouped together without padding or repetition.

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

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

The description is unusually complete for a multi-action tool with no annotations: it covers safety, backup, failure conditions, and link-overwrite semantics. It loses a point because a few parameters (notably verify_com and backup) are left for inference, and the output schema exists but does not compensate for those gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the meaning of action, location, target, display, tooltip, and allow_loss, but leaves path, sheet, backup, and verify_com unexplained. This is partial compensation rather than complete parameter coverage.

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

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

The description opens with a specific verb and resource: 'Manage cell hyperlinks' and then enumerates three concrete actions (add, remove, list). It clearly differentiates this tool from siblings like set_cell or set_formula by focusing on hyperlink-specific behavior.

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

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

The description gives clear context for when each action is appropriate and even notes read-only status for list. It also supplies exclusions such as 'Refuses while open in Excel' and the allow_loss requirement for hazardous workbooks, though it does not explicitly name alternative sibling tools.

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

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

With no annotations, the description fully carries the behavioral burden. It discloses that delete/rename break references to #REF!, that the last visible sheet cannot be deleted/hidden, that hazardous workbooks refuse without allow_loss, and describes backup and atomic-save behavior. This is exceptionally transparent.

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

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

The description is dense but appropriately sized for a 9-parameter lifecycle tool. The action list is front-loaded, followed by high-value consequences and safety behavior. Every sentence adds necessary information without padding.

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

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

The description is thorough for a complex, mutation-heavy tool: it covers actions, parameter combinations, refusal conditions, destructive side effects, backup behavior, and open-file handling. The only notable gap is the unexplained verify_com parameter, which prevents a perfect score.

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 maps nearly every action to its relevant parameters and explains index, state, backup, new_name, and allow_loss. However, verify_com is not explained at all, and path is only implied rather than explicitly defined.

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

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

The description names the resource (worksheet lifecycle) and enumerates every supported action with the parameters each one takes. This clearly distinguishes it from sibling tools like read_range, set_cells, or modify_grid_structure.

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

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

It provides concrete usage context: when actions will be refused, when allow_loss is required, the need to audit references before delete/rename, and refusal while open in Excel. It does not explicitly name alternative tools, but the action enumeration makes the tool's scope unambiguous.

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

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

No annotations exist, so the description carries the full burden of behavioral disclosure. It reveals major side effects: every reference type shifts, deleted references become #REF!, edge-pushing inserts refuse, backups are rotated, saves are atomic and verified, and Excel-lock refusal occurs. This is exceptional transparency.

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

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

The description is long but every clause carries distinct operational meaning. It is front-loaded with the core purpose, then parameter semantics, then edge cases and safety behavior. There is no filler or repetition.

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

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

For a complex mutation tool with no annotations, the description is remarkably complete: it covers reference rewrites, failure modes, loss prevention, backup behavior, and response counts. The only notable omission is clarification for verify_com and sheet, but the overall context is sufficient for safe invocation.

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

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

Schema coverage is 0%, so the description must compensate. It does explain action, at, count, backup, and allow_loss meaningfully. However, path, sheet, and especially verify_com are not described; verify_com is opaque from the property name alone. The description partially compensates but leaves gaps for some optional 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 names a specific verb and resource: inserting or deleting rows/columns with full reference rewriting. This clearly distinguishes it from sibling tools like set_cells, apply_edits, or set_dimensions. The scope is explicit 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 makes clear when the tool is appropriate: any structural row/column insertion or deletion that must keep the workbook coherent. It also states refusal conditions, such as hazardous workbooks requiring allow_loss and Excel-open refusal. It does not explicitly name alternative sibling tools, but the use case is well bounded.

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

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

With no annotations, the description carries the full burden and does so thoroughly. It discloses reference rewriting, destination overwrite, hazardous-workbook refusal, auto-backup, atomic verified save, and refusal while open in Excel. This is rich behavioral context beyond the basic action.

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 dense but well-structured: each sentence delivers a distinct constraint or behavior, with the core action first followed by guardrails. There is no filler or redundancy.

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

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

Given the tool's complexity (7 parameters, no annotations, no schema descriptions), the behavioral and safety aspects are covered exceptionally well. However, the missing parameter semantics for source/dest representation prevent full completeness; the output schema mitigates return-value ambiguity.

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

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

Schema description coverage is 0%, so the description must compensate, but it only references allow_loss by name and does not explain the format or meaning of source, dest, path, sheet, backup, or verify_com. Essential invocation details are missing.

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

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

The description states a specific verb ('Move'), resource ('rectangle'), and destination ('new anchor on the same sheet'), and distinguishes the operation from cross-sheet moves by explicitly refusing them and pointing to copy_range/clear_range. This makes the tool's role clear among sibling tools.

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

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

The description provides explicit conditions: cross-sheet destination is refused and users should use copy_range then clear_range instead; hazardous workbooks require allow_loss=true; tool refuses while the file is open in Excel. This gives the agent clear when-to-use and when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden, and it excels: it declares read-only, explains CACHED vs. recalculated values (uncalculated formulas read as blank), numeric-vs-text comparison coercion, blanks never satisfying ordered comparisons, regex timeout guarding, and precise Excel-compatible aggregate semantics (sum/avg/min/max consume numeric cells only; count is raw row count; exclusions are reported). This is exceptionally detailed behavioral disclosure.

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

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

Dense but never wasteful — every clause earns its place. The structure is logical: operational behavior first, then a 'Semantics:' block for edge cases. For a 15-parameter tool with subtle Excel-compatible behaviors, the length is fully justified rather than bloated.

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

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

Given high complexity, zero annotations, and an output schema covering return shape, the description is remarkably complete. It covers purpose, all behaviors, edge cases, and the safety profile ('Read-only'). The only omissions — exact error behavior and the alternative values for the 'values' param — are minor against the depth provided.

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

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

Schema description coverage is 0%, so the description must compensate — and it does thoroughly. It explains location (defaults to true used range), header (first row names columns), where/match (predicate list with all 13 ops), columns (projection), order_by (direction refusal), offset/limit (paging), distinct, aggregate/group_by/records (function list and output shape), and values ('cached' semantics). Only path and sheet are left to inference, a minor gap against 15 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?

Opens with a specific, multi-verb statement of scope: 'Filter, project, sort, paginate, and aggregate a range SERVER-SIDE.' The resource ('a range') and the differentiating benefit (reading only needed rows/columns vs. a whole sheet) are explicit, which cleanly separates it from siblings like read_range and get_grid_view.

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

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

The description gives clear context for when to invoke this tool — 'so an agent reads only the rows and columns it needs instead of a whole sheet' — implying it is the choice for server-side subsetting. However, it never explicitly names an alternative tool (e.g., read_range) or states when not to use it, so it stops short of explicit when/when-not guidance.

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

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

With no annotations, the description carries the full behavioral burden. It clearly states the operation is read-only, explains how the values parameter distinguishes cached/formula/both modes, and discloses the subtle 'absent' labeling for formula cells without cached values instead of presenting them as blank.

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 definition is dense but compact: each clause adds a distinct fact, and the important scope and read-only property appear early. The values modes are clearly separated with quoted literals rather than buried in a long paragraph.

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

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

For a 4-parameter read tool with an output schema, the description covers operation, location variants, value semantics, sheet defaults, and the large-range alternative. It is incomplete only because path is left undefined and the exact JSON structure of the location object is not shown beyond naming its forms.

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 richly defines location (with nine accepted forms) and the values options, and explains sheet fallback, but it never explains the required path parameter, leaving a meaningful gap for a required input.

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

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

The description opens with a specific verb-resource pair, 'Read a cell or range,' and then enumerates the accepted location object forms. It also distinguishes itself from siblings by stating it is read-only and pointing large-range reads to query_range, so it is not confused with write or query 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?

It explicitly says to page large ranges with query_range, giving one concrete alternative. It also implies read-only use is the intended context, but it does not enumerate when not to use read_range versus other read-oriented siblings such as get_cells.

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

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

With no annotations, the description carries the full burden and does so thoroughly: batch atomicity, dry-run previews, numeric coercion, formula-injection protection, hazardous-workbook refusal, auto-backup, atomic save, and refusal while open in Excel. This is exemplary disclosure of side effects and edge-case 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 dense yet tightly packed, with the core purpose front-loaded and each sentence adding meaningful behavioral detail. No filler or redundant restatement of the tool name exists.

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 13-parameter, mutation-heavy tool with no annotations and only a thin schema, this description covers the critical decision points and risks comprehensively. The presence of an output schema means return-value details are not required, and nothing essential for safe invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it significantly does: match, look_in, dry_run, formulas, allow_loss, backup, and replace semantics are explained. A few parameters like sheet, location, match_case, and verify_com are not explicitly defined, preventing a 5.

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

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

The description states a specific verb ('find-and-replace') and a clear resource ('workbook, sheet, or range'), with explicit matching modes and target scopes. It is easily distinguishable from sibling tools like find_cells (search only) or set_cells (direct writes).

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

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

Provides clear context on how to use the tool: match modes, look_in behavior, dry_run versus real run, and safety toggles. It does not explicitly name alternatives or state when not to use this tool, but the operational guidance is strong enough for an agent to decide when to invoke it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, and it excels: it reveals formula normalization, no literal escape for '=' strings, recalculation flags, hazardous-workbook refusal, backup rotation behavior, atomic verified saves with rollback, and the Excel-open lockout. This is far more transparent than typical tool descriptions.

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 dense but not wasteful; every clause contributes meaningful behavioral information and the core action is front-loaded. The final sentence packs several distinct behaviors together, but nothing is fluff, so the length is justified 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?

For a complex mutation tool with no annotations, this is a very complete description: it covers formula behavior, backup strategy, persistence safety, and failure conditions, and an output schema exists so return details are unnecessary. Minor gaps, such as how location objects are constructed and explicit path/sheet semantics, keep it from being fully comprehensive.

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

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

Schema coverage is 0%, but the description compensates for most non-obvious parameters: value's formula/literal semantics, backup's rotation toggle, allow_loss's safety bypass, and location as the addressing object. It does not fully explain path, sheet, or the exact shape of the location object, leaving some burden on the schema property names.

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

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

The description opens with a specific verb-resource pair: "Write a single cell addressed by a location object." It clearly limits the action to a single cell, which distinguishes it from range-writing siblings like write_range or set_cells, and the additional formula-vs-literal detail makes the purpose even more precise.

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

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

The description gives clear contextual guidance for when this tool is appropriate: for writing a single cell, with explicit conditions around hazardous workbooks and Excel lockout. However, it never names alternative tools for multi-cell writes or formula-specific writes, so exclusions are implied rather than stated.

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

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

With no annotations, the description carries the full burden and does so impressively. It discloses atomic batch semantics, pre-resolution of all addresses, all-or-nothing failure on a bad item, formula normalization, hazardous-workbook refusal with allow_loss escape, auto-backup, atomic verified save, and refusal while the workbook is open in Excel.

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 dense but every clause earns its place. It front-loads the core purpose, then layers the critical behavioral details in a logical order without 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?

The description covers the essential use case, failure modes, safety behavior, and key constraints. An output schema exists, so return-value documentation is not the description's responsibility. The main completeness gap is the undocumented 'verify_com' parameter, which the description does not illuminate.

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

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

Schema description coverage is 0%, so the description must compensate. It adds strong semantic detail for 'cells' (item shape, cell addressing, 1,000-cell ceiling), 'allow_loss' (hazardous workbook escape), and backup behavior. However, it leaves 'sheet', 'path', and especially 'verify_com' unexplained, so the compensation is not complete.

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

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

The description opens with a specific verb and resource: 'Write many individually addressed cells as ONE atomic batch'. It also identifies itself as 'the scatter complement to write_range', making the distinction from the sibling tool explicit and eliminating ambiguity.

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

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

The description names write_range as the complementary alternative and implies this tool is for individually addressed cells rather than contiguous ranges. However, it does not explicitly state when *not* to use it, such as for a single cell via set_cell or a rectangular range via write_range.

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

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

With no annotations provided, the description carries the full burden and excels: it discloses the best-effort approximation of autofit, the allow_loss safety gate for hazardous workbooks, auto-backup to .ks4xl-backups, atomic verified save, and refusal while the file is open in Excel. These are meaningful behaviors beyond the basic action.

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 sentences contain the core action, parameter semantics, caveats, safety behavior, backup side effect, and failure condition—all without filler. The most distinctive operation is front-loaded, making it easy to scan.

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

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

Despite 10 parameters and no annotations, the description covers the operation's mechanics, safety gates, side effects, and environmental constraints. The presence of an output schema means return-value details are not necessary, so nothing critical is missing.

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

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

Schema description coverage is 0%, and the description compensates well for the most complex parameters: column_widths (Excel character units), row_heights (points), and autofit_columns (best-effort approximation). It also covers hiding rows/columns and allow_loss in context, though verify_com and backup receive lighter treatment.

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

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

The description opens with a specific verb and resource: 'Set column widths and row heights, hide rows or columns, and service an autofit request.' This clearly distinguishes it from sibling tools like set_cell, set_view, or format_cells, which target different aspects of the workbook.

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 makes usage context clear by enumerating the operations and key constraints: 'true autofit needs Excel via the com pack', 'hazardous workbook refuses unless allow_loss is true', and 'Refuses while open in Excel.' It does not name alternative tools explicitly, but the conditions of use and important exclusions are stated.

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

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

With no annotations, the description carries the full burden and does so thoroughly. It discloses destructive effects (hiding rows), evaluation over cached and literal values, formula-related warning behavior, refusal for hazardous workbooks unless allow_loss is true, auto-backup, atomic verified save, and refusal while the file is open in Excel.

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 dense and front-loaded, with no filler, but the single-sentence structure with many semicolon-separated caveats is harder to parse than a short structured list would be. It earns its words but could benefit from clearer segmentation.

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 complex mutating tool with no annotations, this is notably complete: it covers safety, backup, save behavior, and row-hiding semantics. Gaps remain in defining what makes a workbook 'hazardous' and what verify_com controls, but the agent has enough to invoke the core operation correctly.

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

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

The schema has 0% description coverage, so the narrative must compensate. It meaningfully explains criteria structure, ops semantics, AND combination, allow_loss, backup behavior, and the location-as-range concept. However, verify_com is left unexplained, and path and sheet receive only implicit meaning from their names.

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

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

The description opens with a specific verb and resource: applying an autofilter over a range with a header row and hiding non-matching rows. It also distinguishes this from simply storing filter criteria in .xlsx, which clarifies its unique role among siblings like query_range and clear_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?

The description provides clear operational context: criteria are evaluated and rows are physically hidden, with behavior for uncalculated formulas and hazardous workbooks. It does not explicitly name alternative tools such as clear_filter or query_range for when to use them instead, but the semantics are clear enough to guide selection.

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

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

With no annotations available, the description carries the full behavioral burden and does so extensively. It discloses formula normalization, #NAME? avoidance, recalculation flagging, stale cached results, the recalculate tool dependency, auto-backup behavior, atomic verified save, and refusal while Excel has the file open. This is unusually transparent.

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

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

The description is dense but every sentence earns its place: core behavior, normalization/recalculation consequences, backup/atomicity, and an important constraint are all covered with no filler. The most important distinguishing behavior is front-loaded.

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

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

The description is remarkably complete for behavioral context, covering side effects, safety, and recalc implications. It loses a point because several parameters remain under-documented given the 0% schema description coverage, and it does not explicitly route to sibling tools for non-formula writes. Overall, it gives an agent enough to operate safely.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It adds meaningful context about 'formula' and 'location' by describing single-cell versus range-fill behavior, and indirectly explains 'backup'. However, key parameters like path, sheet, allow_loss, verify_com, and the exact location format are left unexplained, 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 a specific verb ('Write a formula') and resource ('a single cell, or fill a range'), and clarifies the exact Excel-copy semantics with relative reference shifting and absolute anchors. This clearly differentiates it from siblings like set_cell, write_range, or apply_edits.

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

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

The description makes it clear when to use the tool: when writing formulas to a cell or filling a range with formula semantics. However, it does not explicitly mention alternatives, such as using set_cell for plain values or write_range for non-formula data, nor does it state when not to use this tool beyond the Excel-open refusal.

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

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

With no annotations, the description fully carries the behavioral burden: it discloses data-loss refusal behavior, the confirm_data_loss flow, overlap refusal, unmerge semantics, hazardous-workbook allow_loss handling, auto-backup, atomic save, and refusal while Excel is open. These are exactly the side effects an agent needs to anticipate.

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 dense but every sentence earns its place. It front-loads the primary modes and then proceeds logically through constraints, data-loss behavior, safety checks, backup, and concurrency without filler.

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

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

For an 8-parameter mutation tool, the description covers core semantics, failure modes, persistence behavior, and the Excel lock condition. The output schema can handle return values, so the remaining gaps around verify_com and exact backup toggling are minor rather than blocking.

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

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

Despite 0% schema description coverage, the description explains the meaningful semantics of action, location, sheet, confirm_data_loss, allow_loss, and backup behavior. It does not explain verify_com and only implicitly addresses the backup toggle, but the most consequential parameters are well covered.

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 three modes—merge, unmerge, and list—and ties each mode to the action parameter. It is unmistakably distinct from sibling tools like set_cell or write_range because it deals specifically with cell merge state.

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

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

The description gives concrete usage guidance for each action, including the exact location constraint for merge versus unmerge and the read-only nature of list. It also states refusal conditions such as overlap and data loss, which tells the agent when not to proceed; it just does not name alternative sibling tools, though none are better suited.

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

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

With no annotations, the description alone discloses key behaviors: freeze strings and semantics, split exclusivity with freeze, coordinate units, zoom limits, selection format, tab color sentinel, persistence of unset params, auto-backup, atomic verified save, and refusal while open in Excel. This goes far beyond the schema.

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

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

The description front-loads the core purpose and then packs every remaining statement with operational detail; no filler. It is long only because there are 12 parameters and complex semantics.

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

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

Given no annotations and an input schema with bare property names, the description covers the most operationally significant parameters and behaviors, and an output schema exists to cover return values. Small gaps remain for allow_loss and verify_com, and no alternative routing is provided, so it falls just short of fully comprehensive.

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

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

Schema description coverage is 0%, so the description compensates by explaining freeze special values, split object semantics, zoom range, selection A1 notation, tab color hex/'clear', and backup behavior. Parameters like path, allow_loss, and verify_com are left for inference, so it is not fully complete.

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

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

The description opens with a specific verb and resource ('Set sheet-view state') and enumerates the exact facets it manages (freeze, split, gridlines, headings, zoom, selection, tab color). This distinguishes it from sibling mutators like format_cells or set_dimensions even without naming alternatives.

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

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

The description establishes clear context for what the tool configures and notes defaults (unset parameters keep current values, active sheet). It does not, however, name alternative tools or state when not to use it, so the agent must infer the boundary from the sibling list.

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

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

With no annotations at all, the description carries the full disclosure burden and does so excellently. It reveals partial-update semantics, a read-only fallback, the cache-staleness risk of manual calc mode, auto-backup and atomic verified save, and a lock-out condition when the file is open in Excel. This goes well beyond a generic 'sets properties' statement.

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 compact sentences deliver purpose, parameter details, and caveats without redundancy. The load-bearing facts are front-loaded, and every phrase either adds semantic detail or a behavioral warning. No filler or recapitulation of the schema.

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

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

For a 15-parameter mutation tool with no annotations, this description covers an impressive amount: operations, effects, failure conditions, and mode-specific warnings. The presence of an output schema excuses not explaining return values. The main gaps are the two unexplained parameters (allow_loss, verify_com) and a lack of any explicit pointer to a sibling read tool for metadata-only queries.

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

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

The schema has 0% description coverage, so the description must compensate. It explains most parameters: the six document properties, calc_mode with its enum values, full_calc_on_load, iterative_calc with max_iterations and max_change, and null-means-leave-unchanged semantics. However, allow_loss and verify_com are not mentioned at all, and the backup parameter is only implied via 'Auto-backup', leaving some agent-facing 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 opens with a specific verb and resource: 'Set core document properties... and calc settings', then enumerates the exact fields involved. It also clarifies a dual read/write mode ('with none it reports current values read-only'), which removes ambiguity about what the tool does and how it differs from a purely mutable setter.

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

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

It provides clear behavioral conditions: 'Only given parameters change; with none it reports current values read-only' and 'Refuses while open in Excel.' It also warns about the real-world consequence of manual calc mode. It does not explicitly name alternative sibling tools or say 'use X instead for metadata reads', so it falls just short of full when/when-not guidance.

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

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

With no annotations, the description carries full behavioral disclosure, and it does so thoroughly. It explicitly describes mutation, formula reference shifts, cached-value comparison with warnings, hidden-row pinning, auto-backup as undo, atomic saves, and refusal conditions. This is far beyond minimal disclosure.

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

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

Every sentence adds meaningful behavior, with the primary action front-loaded, followed by key semantics and then edge cases and safety. There is no filler, and the high information density remains readable.

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 complex 8-parameter mutation tool with no annotations, the description is unusually complete: it covers mutability, key semantics, formula behavior, hidden rows, backup/undo, and concurrency refusal. The only gaps are optional parameters sheet and verify_com, which are low-risk and not central to correct sorting calls.

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

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

At 0% schema description coverage, the description compensates well for the most complex parameter (keys), explaining column identification via header name, letter, or index, asc/desc order, and tie-breaking. It also clarifies has_header, backup, and allow_loss, but leaves sheet and verify_com unexplained and only implicitly covers location through 'range or table body'.

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 specific action: sorting a range or table body by one or more keys and writing rows back reordered. This distinguishes it from sibling read/write/query operations, and the detailed key-structure description leaves no doubt about what the tool does.

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

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

Provides strong operational context: key formats, tie-breaking, header behavior, Excel-consistent handling of formulas and hidden rows, and explicit preconditions like allow_loss for hazardous workbooks and refusal while open in Excel. It does not name alternative tools, but no sibling performs sorting, so the context is sufficient.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It thoroughly explains read-only semantics, the meaning of passed=false, what each check covers, and that external links are reported but not repaired. This is far beyond the structured data available.

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 dense but well-organized, front-loaded with the core purpose and followed by a structured enumeration of check types, return semantics, and operational notes. Every sentence and parenthetical carries useful information without padding.

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

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

Given that an output schema exists and the description covers default behavior, check semantics, return semantics, read-only guarantees, and the Excel-open requirement, the tool description is complete enough for an agent to select and invoke it correctly.

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

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

The checks parameter is documented in exceptional detail, including its default value and every possible check option with meaning. The path parameter is not explicitly described, but the file context is implied throughout. Schema coverage is 0%, so the description compensates strongly, though not completely for path.

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

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

The description opens with a specific verb and resource: 'Run read-only correctness checks and return one report.' It clearly distinguishes itself from sibling editing tools by emphasizing read-only behavior and enumerating concrete check types, 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 tells the agent this is for correctness validation, works while the file is open in Excel, and explicitly states that repairs belong to the editing tools. It gives clear context for when to use the tool, though it does not name specific alternative sibling tools or provide explicit when-not-to-use criteria.

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

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

With no annotations, the description carries full behavioral burden and does so thoroughly. It discloses ragged-row refusal, null-padding clearing behavior, formula normalization, recalculation flagging, grid limits, the 200,000-cell ceiling, hazardous workbook refusal, allow_loss behavior, auto-backup, atomic verified save, and refusal while open in Excel.

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 dense but every sentence carries a distinct behavioral or safety constraint. It is front-loaded with the primary action and follows with high-value details, with no filler or repetition.

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

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

For a 7-parameter mutating tool with no annotations, the description is unusually complete: data format, limits, failure modes, persistence, and safety are all covered. Minor gaps remain around verify_com and sheet selection, but an output schema exists and the core calling contract is well specified.

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

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

Schema coverage is 0%, so the description must compensate. It explains data as a list of row lists that must be rectangular, describes location as the top-left anchor, clarifies allow_loss for hazardous workbooks, and mentions backup behavior. However, it does not explain verify_com or sheet 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?

Description opens with a specific verb and resource: 'Write a 2D block of values and formulas anchored at the location's top-left cell.' It also scopes the operation by noting content outside the block is never touched, which clearly differentiates it from single-cell and other range tools like set_cell, set_formula, and apply_edits.

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

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

Usage context is implied through the 2D-block description and constraints like ragged-row refusal, but there is no explicit when-to-use versus when-not-to-use guidance or named alternatives. An agent can infer the intended use case but is not explicitly routed away from sibling tools.

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