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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond them: how the data range is interpreted (first column = X axis/labels, subsequent columns = series, header row supplies series names). It does not note permissions/account implications or that the chart is written into the sheet, which keeps it from a 5.

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

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

Three tightly packed sentences with zero filler. The core action is front-loaded and the data-layout rules follow immediately in the order an agent would need them.

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 non-destructive mutation tool with no output schema, the safety profile is covered by annotations and the data-shape rules are explained, but chart_type/stacked behavior, the effect of omitting anchor_cell, and the return value are left entirely to the schema or unstated. Adequate, not complete.

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

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

With 8 parameters at 50% schema coverage, the schema does only half the work. The description usefully clarifies the semantics of data_range and has_header (column-to-series mapping, header row for series names), but says nothing about chart_type, stacked, anchor_cell, title, or account choices. Partial compensation only.

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

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

The description gives a specific verb (Create) and resource (chart) plus the source of the data (a data range), which cleanly separates it from update_chart and delete_chart in the sibling list. It stops short of naming those siblings or otherwise explicitly stating the boundary, so it is clear but not maximally differentiated.

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

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

Usage is only implied: an agent can infer 'use this when you want a new chart,' but the description never says when to prefer add_chart over update_chart, nor does it state prerequisites such as needing an existing data range with values. No explicit when-not or alternative is offered.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the safety profile is partly covered. The description adds that two rule shapes exist but omits key mutation context: whether rules stack or replace existing ones, precedence/ordering, and any permission requirements.

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

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

A single front-loaded sentence with zero filler; the two rule modes are surfaced up front. It is efficient, though the terse phrasing leaves gaps that a slightly longer description could have closed.

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

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

For a mutation tool with nested objects, no output schema, and no enums, the description conveys the two entry points but omits behavioral details (rule stacking, replacement, interaction with existing formatting) that an agent needs to call it correctly.

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

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

Schema coverage is 60%, and the description only loosely restates what the schema already documents (condition types, color scale). It adds 'with a style' but does not explain the undocumented nested fields (bold, text_color, background_color, min/mid/max colors) or how values maps to the condition type.

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

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

States a specific verb ('Add') and resource ('conditional formatting rule') and enumerates the two supported forms (condition+style or color scale). It does not distinguish this from the sibling format_range, so it falls short of a 5.

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

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

The description implies when each parameter path applies by presenting the two mutually exclusive modes, which helps an agent choose between 'condition' and 'color_scale'. However, it gives no explicit when-to-use vs. static formatting (format_range/format_ranges) or any prerequisites.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, openWorldHint=true; the description adds the key side-effect disclosure that a new tab is created unless anchor_cell is given, and warns of the anchor-cell area constraints implied by the schema. Adds write-location context beyond the security profile.

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 tight sentences, front-loaded with purpose, then placement behavior, then the prerequisite. No repetition of schema fields; every clause earns its place.

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

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

For a 9-parameter mutation tool with no output schema, the description covers purpose, side effects, and prerequisites adequately. Minor gap: it doesn't clarify that show_totals/new_tab_name interact with the default placement, though the schema implies this.

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 78%, so the schema carries most parameter detail, but the description adds genuine semantics: that columns may be referenced by header name or letter and that a header row is required — neither stated in the schema itself. This meaningfully reduces invocation error.

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?

Specific verb+resource: "Summarize a table with a pivot table." No sibling tool creates pivot tables, so the purpose is immediately unambiguous and distinguishable from add_chart, set_filter, and sort_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?

Description gives concrete prerequisites (source range needs a header row, columns referenced by header name or letter) and states the default placement (new tab vs anchor_cell). It lacks explicit when-not-to-use guidance, but no sibling competes for this task.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the genuinely useful detail that the append point is auto-detected from the range/tab rather than an explicit row index, but omits whether the operation can extend the sheet beyond current data/grid bounds and what happens to existing formulas or formatting in adjacent rows.

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

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

A single front-loaded sentence with the key behavioral qualifier (detection of the last row) in parentheses rather than buried. No waste, no filler.

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

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

For a mutation tool with no output schema, the description should ideally state what comes back (e.g. updated range/rows written) and whether permissions must be pre-granted. Annotations cover safety and the schema covers inputs, so the gap is moderate rather than severe.

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

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

Schema coverage is 100%: all four parameters carry descriptions covering range syntax, formula strings, account resolution and spreadsheet identifiers. The description adds nothing beyond the schema (its 'range or tab' phrasing merely echoes the range parameter), so the baseline 3 is appropriate.

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

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

States a specific verb+resource (append rows) and pins down the insertion point ('after the last row of data in a table'), which meaningfully separates it from write_range or insert_rows_or_columns. It stops short of naming those siblings explicitly, so an agent still has to infer the boundary.

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 usage context (append to a table detected from the given range or tab) but gives no explicit when-to-use/when-not guidance and never names write_range, insert_rows_or_columns, or fill_range as alternatives. Adequate but leaves the routing decision to inference.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely new context: these are raw API requests requiring sheetId numbers obtained from get_spreadsheet_info, and it points to the Request object reference. It does not note batch-composition restrictions (e.g. requests that must run alone) or that malformed requests can damage sheets, but the bar is lower with annotations 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?

Two sentences, zero waste, front-loaded with the tool's identity and role before the example list. The prerequisite pointer (get_spreadsheet_info) is placed last where it belongs.

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 raw-API escape hatch with no output schema, the description covers purpose, routing, request shape prerequisites, and ID sourcing. It stops short of warning about request-format pitfalls specific to batchUpdate (ordering/atomicity constraints, partial-failure behavior), which would be the remaining high-value detail.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by specifying that requests must use sheetId numbers (not names or A1 references) and by pointing at get_spreadsheet_info as the source for those IDs, which the schema itself only gestures at via an external docs URL.

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

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

States a specific verb and resource ("Send raw Google Sheets API batchUpdate requests") and immediately scopes it as the catch-all: "anything the other tools don't cover," with a concrete example list (named ranges, protected ranges, pivot tables, row heights, hiding rows, charts). An agent can distinguish this from format_range, add_chart, or add_pivot_table without opening any schema.

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

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

Gives a clear routing rule: use this only for capabilities the other tools don't cover, with examples that make the boundary concrete. It does not name the specific sibling tools to prefer first (format_range, add_chart, etc.), so the exclusion is implied by category rather than explicit, but the context is 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so safety is covered; the description adds genuinely new behavior — that formatting survives the clear and that contents are retained for undo_last. It still doesn't explain the undocumented dry_run flag's effect or any limits on undo.

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

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

Two tight sentences with the destructive scope front-loaded and the formatting/undo caveat immediately after; every clause earns its place.

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

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

For a 4-param mutation with annotations covering safety and no output schema, the description supplies the two behaviors an agent most needs (formatting preserved, contents recoverable). The unexplained dry_run parameter is the only real omission.

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 75% and the schema itself gives A1 syntax, account resolution, and spreadsheet ID semantics, so the description is correct to stay out of it. However, dry_run is documented nowhere, and the description adds no parameter meaning beyond the schema.

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

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

States a specific verb+resource (clear values and formulas in a range) and adds a scope qualifier — formatting is kept — that separates it from destructive range/row operations. It does not name a sibling like delete_rows_or_columns or format_range to route the agent explicitly, so it stops short of a 5.

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

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

The mention that previous contents are saved for undo_last implies a recoverable workflow, which is light usage context, but there is no explicit when-to-use vs. write_range/fill_range/format_range guidance and no stated preconditions.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: it doesn't say where the spreadsheet is created, what permissions/default sharing apply, or what state the caller gets back.

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

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

A single efficient sentence with no waste and no burying of the key action. It is arguably under-specified rather than well-structured, but the front-loading is correct.

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 creation tool with no output schema, the description should at minimum indicate what the caller receives back (spreadsheet ID/URL) so the result can be chained into read_range or batch_update. It also omits behavior for duplicate titles and default tab creation, leaving the agent under-informed about a mutating, open-world operation.

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

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

Schema coverage is 67%: account and sheet_names carry descriptions, but the required 'title' parameter does not. The description contributes no parameter meaning at all, so it neither compensates for the title gap nor improves on the schema.

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

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

States a specific verb (Create) and resource (Google Sheets spreadsheet), so an agent can immediately tell it apart from read/write/format siblings. However it offers no explicit sibling differentiation beyond the obvious create-vs-modify distinction.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g. required scopes or account context), and no mention of what happens if a same-named spreadsheet exists. The agent must infer usage entirely from the name.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, but the description adds a genuinely new trait: the deletion cannot be reversed through undo_last, which is not captured by the annotations and directly affects agent risk assessment. It does not cover permission requirements or side effects on the spreadsheet beyond the chart.

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

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

Two short sentences, no filler, with the core action first and the two operational facts (id provenance, irreversibility) following. Every clause carries load.

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

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

For a destructive, no-output-schema operation the description supplies the essentials: what it does, where the id comes from, and that it is irreversible. Minor gaps remain on whether the spreadsheet must be open or what happens to the surrounding sheet data, but nothing critical to invoking it 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 67%: account and spreadsheet are documented in-schema, but chart_id has no schema description. The description compensates by explaining exactly where valid chart ids come from, which is the key missing piece. This is above the baseline-3 case where the schema does all the work.

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

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

States a specific verb and resource ("Delete a chart") and names where the required chart_id originates (get_spreadsheet_info or add_chart), which pins down the operation precisely. The verb clearly separates it from add_chart and update_chart, though it does not explicitly contrast itself with those 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?

Provides a concrete prerequisite path for obtaining the required chart_id (get_spreadsheet_info or add_chart) and a caution that the action is not recoverable via undo_last, which shapes when an agent should commit to calling it. It stops short of an explicit "use this instead of X when Y" statement.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the safety class is known. The description adds genuinely new behavioral context beyond that: 'Not undoable' tells the agent the operation is irreversible, which the annotations do not express. It stops short of describing downstream effects such as shifted references or formulas breaking.

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

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

Two sentences with zero filler; the destructive constraint is front-loaded alongside the operation and the irreversibility warning closes it. Every clause carries 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?

With annotations covering safety and a fully described schema, the definition supplies what an agent needs to call it: accepted range formats and the irreversibility caveat. It is only slightly short on what happens to surrounding data (cell shifting, reference breakage) and how to recover.

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

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

Schema description coverage is 100%, so all three parameters (range, spreadsheet, account) are already documented in the schema, including the same range examples. The description repeats the example formats but adds no syntax or constraint the schema lacks, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Delete entire rows ... or columns') and immediately disambiguates from the sibling insert_rows_or_columns by naming the delete direction. The inline range examples make the target object unambiguous without opening the schema.

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

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

Usage is only implied: the description never says when to prefer this over clear_range (which empties cells without shifting) or insert_rows_or_columns, nor does it mention undo_last as the recovery path. The range examples give the shape of a valid call but not the selection criteria between alternatives.

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

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

Adds substantive behavior beyond the annotations: it discloses that the destination's previous contents are saved for undo_last, which confirms and deepens the destructiveHint=true signal, and it notes that formula errors found after filling are returned. These are exactly the traits an agent needs to reason about a destructive mutation.

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

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

Front-loads the core behavior, then usage guidance, then the continue_series variant and side effects. Four dense sentences that mostly earn their place, though it borders on long for the amount of structured data already present.

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

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

With no output schema, the description usefully reports what is returned (formula errors), covers the recoverability of the destructive write, and explains the mode/parameter behavior. Combined with full schema coverage and accurate annotations, an agent has everything needed to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantics: it explains continue_series with concrete examples (1, 2, 3 → 4, 5, 6; Jan → Feb; dates) and clarifies relative-reference shifting that the schema only gestures at.

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

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

States a specific verb and resource ('Fill cells from a source block') with an evocative analogy ('like dragging the fill handle or pasting onto a bigger selection') and spells out exactly what propagates: formulas with relative-reference shifting, values, and formatting. This clearly separates it from sibling tools like write_range, append_rows, or format_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?

Gives a concrete when-to-use ('after writing one row or column of formulas to extend them across a table, instead of sending every column') and describes the continue_series alternative path with examples. It lacks an explicit 'when not to use' or a named sibling alternative, so it stops short of a 5.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, but the description adds the critical detail that the edit cannot be undone by undo_last, plus the suggested read-before-write workflow. That is genuine value beyond the structured hints; it does not, however, describe the blast radius (e.g. how many cells get rewritten) or the response.

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

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

Two sentences, zero filler, with the scope statement front-loaded and the risk warning immediately after. Nothing redundant with the title or annotations.

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

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

For a destructive, 9-parameter mutation with no output schema and low schema coverage, the description covers the most important context (irreversibility) but omits the semantics of the replacement modifiers. An agent could still make a wrong-scoped replacement (regex on/off, formulas included) without further guidance.

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

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

Schema coverage is only 33% across 9 parameters, and the description adds nothing about them. Behavioral modifiers that materially change the operation -- use_regex, include_formulas, match_case, match_entire_cell -- are undocumented in both the schema and the description, leaving the agent to guess what will actually be replaced.

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

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

States a specific verb+resource ('find and replace text') and its scope ('across a tab or the whole spreadsheet'), which maps cleanly to the sheet parameter's default of all tabs. No sibling performs find/replace, so differentiation is implicit rather than stated, but the action is unambiguous.

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

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

Gives a concrete precaution ('Not undoable - consider read_range first') and names read_range as the alternative to consult before mutating. It stops short of stating when this is the right tool versus write_range/fill_range for bulk edits, but the cautionary routing is clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds valuable context beyond that: the match set is a local list kept on the user's computer, the search is limited to that list, and empty-query behavior lists recent items. It does not discuss auth or result ordering limits, keeping it just short of a 5.

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

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

Front-loads the core action and scope in the first clause, then layers trigger, limitation, fallback, and default behavior. Sentences are dense but each carries distinct information; only slight compression could improve it.

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

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

For a simple single-parameter lookup tool with no output schema, the definition covers scope, trigger, limitation, fallback, and default behavior. Nothing an agent needs to call it correctly 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 100%, so the baseline is 3. The description goes further by explaining that the sole optional parameter accepts part of a name and that leaving it empty lists the most recent, adding semantics the schema alone does not convey.

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

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

States a specific verb and resource ('Find a spreadsheet by name') and immediately bounds the scope to spreadsheets the user has opened or created via Sheets MCP, explicitly noting it cannot search the rest of Google Drive. This distinguishes it from link/id-based siblings like get_spreadsheet_info.

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

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

Gives an explicit trigger ('when the user names a sheet instead of pasting a link, e.g. "my budget sheet"'), an explicit non-capability with a fallback ('can't search the rest of their Google Drive: if nothing matches, ask for the link'), and default behavior ('Leave query empty to list the most recent'). No inference required.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so safety profile is covered. The description adds genuine non-obvious behavior: partial-update semantics (only supplied options are modified), which the annotations do not convey. It does not mention auth requirements or atomicity of the operation.

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

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

Two tightly packed sentences, front-loaded with the action and scope, then the partial-update rule, then the sibling routing. No wasted words.

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

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

For a 17-parameter mutation tool with no output schema and low schema coverage, the description covers the option surface and the crucial partial-update behavior plus alternative routing. It stops short of explaining how clear_formatting interacts with other supplied options or what the result looks like.

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

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

With 17 parameters and only 35% schema description coverage, the description should carry more weight. It lists formatting categories (font, colors, number formats, alignment, wrapping, borders) which aids discovery, but adds no syntax or semantics beyond what the schema already shows for enums, nested objects, or booleans.

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?

Names a specific verb (Apply formatting) and resource (a range) and enumerates the formatting categories covered, so the agent knows exactly what it does. It also explicitly distinguishes itself from the sibling format_ranges, making disambiguation possible without opening either schema.

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

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

"Only provided options are changed" clarifies the update model and "To style several ranges differently in one go, use format_ranges" gives an explicit alternative with its selecting condition. It lacks guidance on prerequisites (account/permissions) or when to prefer clear_range over clear_formatting, but the core routing is present.

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

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

Annotations declare the safety profile (destructiveHint=false, openWorldHint=true), and the description adds a genuinely useful behavioral rule not present in annotations or schema: 'Ranges may repeat; later entries win where they overlap.' It doesn't cover failure/atomicity behavior, so not a 5.

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

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

Two tight sentences, front-loaded with the action and batching scope, followed by the precedence caveat. 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?

For a batch mutation with no output schema, the description covers scope, option inheritance from format_range, and overlap resolution. It leaves gaps on error/atomicity semantics for a partially-failing batch, but is otherwise sufficient given the rich schema.

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

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

Schema description coverage is 100%, so the nested item properties (bold, borders, number_format, etc.) are already fully documented. The description only adds 'one entry per range' and the overlap precedence rule; baseline 3 is appropriate.

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

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

States a specific verb (apply formatting) and resource (several ranges) and clearly frames itself as the multi-range variant of format_range by name. The sibling distinction is explicit: 'same options as format_range, one entry per 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 parenthetical '(same options as format_range, one entry per range)' and 'for a whole tab at once' give clear context and imply the single-range alternative, but it never explicitly says when to prefer format_range over this tool.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds non-obvious behavioral context: freezing is reversible by passing 0, which the annotations do not convey. It still omits whether the freeze persists across sessions or what happens to `tab` when unspecified.

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

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

Two short sentences with the primary action front-loaded and the inverse-operation rule second. Zero filler; every clause carries 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 5-parameter mutation with no output schema, the description covers the core action and the unfreeze case but is silent on default tab behavior, whether omitted `rows`/`columns` leaves existing freeze untouched, and the fact that only one required parameter exists. Adequate, but not complete for the schema's complexity.

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

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

Schema coverage is only 40%, so the description must carry more weight. It maps meaning onto `rows`/`columns` (counts of header rows/columns) and clarifies that 0 means unfreeze, which the bare integer schema with minimum 0 does not. However, `tab` is undocumented in both schema and description (e.g. default tab, whether it must exist), leaving a real 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?

States a specific verb (freeze) and resource (header rows and/or columns on a tab), which is unambiguous against siblings like insert_rows_or_columns, resize_columns or format_range, none of which freeze panes. It stops short of explicitly naming a sibling it is not, so it lands at 4 rather than 5.

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

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

"Use 0 to unfreeze" gives a concrete value-level rule for the inverse operation, which is genuinely useful for selecting the right call. There is no explicit when-not or alternative-tool guidance, but the tool is unique in the sibling set, so the implied usage is clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds the useful behavioral fact that it returns only the first few rows per tab rather than everything, but it omits any note on what happens with very large sheets or where the preview cap comes from (the schema caps preview_rows at 20).

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

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

Two sentences, no filler. The enumeration of return contents comes first and the actionable instruction (call this first) is placed at the end as a routing cue, which is well front-loaded for scanning.

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

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

There is no output schema, so the description carries the burden of describing the return shape and does so concretely. Combined with annotations covering read safety and schema-documented parameters, an agent has enough to call this correctly; only edge-case behavior on huge or unusual sheets is unaddressed.

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 67%, with account and spreadsheet thoroughly documented in the schema itself, including the account-resolution fallback behavior. The description's "first few rows of each tab" loosely corresponds to preview_rows but adds no format or semantics beyond what the schema already states (default 3, max 20).

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

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

States a specific verb (get) and resource (spreadsheet info) and enumerates exactly what comes back: title, tabs with sizes and frozen rows/cols, charts with ids/types/data ranges, named ranges, and preview rows. This reads as a layout-discovery operation that is clearly distinct from the range read/write 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?

"Call this first to understand a sheet's layout" gives explicit sequencing guidance for the start of a workflow, which is exactly what an agent needs before reaching for read_range. It stops short of naming alternatives or stating when not to call it, but the usage context is 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?

The annotations cover readOnly=false, openWorld=true, and destructive=false. The description adds meaningful behavioral context beyond them: add opens a browser sign-in and handles expired sessions, remove revokes access, and set_default affects new spreadsheets. This gives the agent useful auth and side-effect awareness.

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

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

The description is a compact single paragraph with the general purpose front-loaded and each action explained in a clause. Every sentence contributes useful information without 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?

There is no output schema, but the description covers all actions, required parameters, sign-in behavior, revocation behavior, and default-account effects. For a two-parameter account-management tool, this is complete enough for correct invocation.

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

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

The schema documents the email parameter but provides no description for the action enum. The description maps all four action values to their effects, adding essential meaning for the action parameter. Email semantics are already covered by the schema, so it does not add extra there.

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 resource ('Google accounts Sheets MCP can use') and enumerates the four action subcommands. This clearly distinguishes it from all sibling spreadsheet tools, so an agent can identify its scope immediately.

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 per-action when-to-use guidance: list for signed-in/default accounts, add for sign-in or expired sign-in, remove to sign out/revoke access, and set_default for choosing the account used for new spreadsheets. The alternatives are internal to the action enum, so no sibling routing is needed.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that inserted cells are 'blank' and positioned 'before' a reference, which is useful context, but says nothing about how existing content, formatting, or references shift, nor about count 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?

A single front-loaded sentence with zero filler that states the action, the inserted content type, and the insertion point. 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?

For a 6-parameter mutation tool with no output schema, the description is thin — it omits count, tab targeting, and the effect of shifting existing rows/columns on formulas or formatting. Annotations and the schema cover the safety profile and most parameters, so this is adequate but leaves real 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 coverage is 67%, so most parameters are described structurally. The description maps to the 'before' parameter (row number or column letter) and implies 'dimension' and 'count', but adds no syntax or format detail beyond the schema and is silent on tab, account, and spreadsheet 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?

States a specific verb (insert) and resource (blank rows or columns) plus the positional constraint (before a given row number or column letter). This distinguishes it from append_rows (adds at the end) in spirit, though it never names that sibling explicitly. Clear, but no explicit sibling differentiation.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. An agent must infer that insert_rows_or_columns is for mid-sheet insertion versus append_rows for appending, and vs delete_rows_or_columns for removal — none of which is 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?

Annotations already declare readOnlyHint=false, destructiveHint=true, and openWorldHint=true, so the safety profile is covered. The description adds almost nothing beyond that: it does not warn that delete irreversibly removes the tab and its data, nor does it mention the account/auth requirements, so it earns little credit over structured fields.

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

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

A single tight sentence that front-loads the verb list with no filler. It is appropriately sized for the tool, though the terseness leaves behavioral context unstated rather than wasteful.

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

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

For a 7-parameter, multi-action, destructive mutation tool with no output schema, the description is thin: it never explains how the parameters interact per action (e.g., tab + new_name for rename/duplicate, rows/columns only for add) or the account default behavior. The rich schema compensates substantially, making this minimally adequate.

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 86%, so the schema itself documents tab, rows, columns, new_name, account, and spreadsheet semantics. The description only restates the action list and adds no format, default, or interaction detail (e.g., tab vs new_name for duplicate), so baseline 3 applies.

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

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

The description names a specific resource (tab/sheet) and enumerates four concrete verbs matching the action enum (add, delete, rename, duplicate). It is clearly distinguishable from siblings like insert_rows_or_columns or delete_rows_or_columns that operate on cell ranges rather than whole tabs, though it never explicitly routes the agent away from them.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of alternatives such as create_spreadsheet for a new file or delete_rows_or_columns for clearing data. The agent must infer selection purely from the action enum, which the schema already provides.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: it never mentions the key behavioral fact that merging discards all values except the anchor cell, and it says nothing about permissions or reversibility. With annotations present the bar is lower, but this still adds no context at all.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though the brevity is achieved by omission rather than by tight editing of richer content.

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

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

For a destructive mutation with five parameters, 60% schema coverage, no output schema and 27 sibling tools, one sentence is not enough. An agent lacks any statement about data loss on merge, when unmerge is appropriate, or how merge_type interacts with the selected range.

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

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

Schema coverage is only 60% (range, account, spreadsheet documented; action and merge_type rely on bare enums). The description's 'merge or unmerge' merely restates the action enum and 'in a range' restates the range parameter, contributing no format, default, or interaction detail beyond the schema.

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

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

The description states a specific verb pair (merge/unmerge) and resource (cells in a range), so an agent immediately knows the operation. It does not distinguish itself from any sibling such as format_range or set_filter, nor does it mention the spreadsheet context, which keeps it short of a 5.

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

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

There is no statement of when to merge versus when to unmerge, no preconditions (e.g. that a range must be selected/contiguous), and no named alternatives. The only implicit guidance is that one tool covers both directions, which mildly discourages the agent from hunting for an 'unmerge_cells' sibling, but that is inferred 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?

Annotations already declare readOnlyHint=true, so safety is covered. The description adds genuinely useful behavioral context that annotations do not carry: large ranges are truncated, and a continuation mechanism (next_range) exists. This truncation/continuation detail is the key value-add.

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

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

Two tight sentences with no wasted words. The primary purpose is front-loaded and the truncation/continuation caveat follows immediately.

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

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

With no output schema, the description does mention the truncation return behavior, and readOnly annotations plus a rich mode enum cover much of the rest. It is largely complete for a read tool, though it could say more about the returned structure or clarify the overlap with 'read_ranges'.

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 80%, and the schema already fully documents the 'mode' enum values. The description only restates the existence of a 'formats' mode rather than adding syntax or semantics beyond what the schema provides, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Read cell contents from a range') and calls out the 'formats' mode, so the core operation is unambiguous. However, it does not distinguish this tool from the very similar sibling 'read_ranges', leaving an agent to guess which of the two to invoke.

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 implies when to use the 'formats' mode versus the default and explains what to do when a range is truncated ('use next_range to continue'). But there is no explicit routing guidance against the competing 'read_ranges' tool, and 'next_range' is not among the listed siblings, so the continuation advice is only partially actionable.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds real behavior beyond that: results are truncated per range to a share of max_cells, and a next_range token exists as a continuation mechanism. It doesn't describe permission requirements or the exact response shape, but the truncation/continuation disclosure is substantive.

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 tight sentences: capability first, sibling comparison second, the non-obvious truncation/continuation behavior last. Every sentence carries distinct information with no repetition of schema content.

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 no output schema, the description covers the important non-obvious return behavior (per-range truncation and the next_range continuation token), which is exactly what an agent needs to avoid mis-handling partial results. It could say more about the returned structure per range, but the critical gap is addressed.

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 80%, so the baseline is already 3. The description goes further by explaining how max_cells is allocated ('truncated to its share of max_cells'), which clarifies a parameter the schema only labels as a total. That added semantics lifts it above baseline.

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

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

States a specific verb and resource ('Read several ranges in one call, across any tabs') and immediately differentiates itself from the sibling read_range by framing batched reads as the point. An agent can tell why this exists versus read_range without opening either schema.

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

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

Explicitly positions itself against the alternative ('Faster than calling read_range repeatedly') and names the continuation path ('use its next_range with read_range to continue'), which tells the agent when to stay and when to follow up. It stops short of stating when NOT to use it (e.g. a single range), but the routing context is clear.

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

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

Annotations already declare this is a non-readonly, non-destructive, open-world mutation. The description adds genuinely new behavioral context the annotations do not: widths are in pixels and omission triggers auto-fit to content. It still doesn't state persistence or permission needs, but against existing annotation coverage that is a minor gap.

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

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

A single front-loaded sentence that delivers both branches of behavior with zero filler. Nothing could be removed without losing meaning.

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

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

For a four-parameter mutation tool with no output schema, the description covers the key semantic gap (width units and default behavior) while annotations cover safety. Missing only peripheral details like required permissions or how multi-column ranges apply a single width.

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 75%, and the one undocumented parameter is the critical 'width' — the description compensates by defining its unit (pixels) and the meaning of omitting it (auto-fit). The remaining unspecified behaviors (e.g., per-column ranges) are minor, so this lands above the baseline 3.

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

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

States a specific verb+resource ('Set column widths') and covers both operating modes (fixed pixels vs. auto-fit). It does not differentiate itself from potential siblings like format_range, which could plausibly touch column sizing, so it falls short of a 5.

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

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

The description implies usage and gives an internal condition — omit 'width' to auto-fit — but offers no guidance on when to choose this tool over format_range or other layout-affecting siblings, and no prerequisites.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), so the description mainly restates the operation list that the schema enum already provides. It never explains whether existing validation on the range is overwritten, what 'clear' removes, or what authorization/account context is required.

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

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

A single front-loaded sentence with the verb and resource first, then the mode enumeration. No filler and nothing 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 an 8-parameter mutation tool with no output schema, the definition is adequate but leaves the type-conditional parameter requirements (which params are needed for dropdown vs number_between vs clear) unexplained. Annotations cover safety and the schema covers most fields, but the type-to-parameter mapping 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 63%, so the schema carries most parameter documentation. The description adds only a restatement of the type modes and implies 'range', saying nothing about min/max for number_between, options payload shape, or strict, so it does not meaningfully compensate for the coverage 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?

States a specific verb (add data validation) and resource (a range), and enumerates the six operation modes that match the type enum exactly. It does not differentiate itself from nearby siblings like add_conditional_format or format_range, which is the only reason it falls short of a 5.

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

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

The mode list implies when each variant applies, but there is no explicit when-to-use guidance, no prerequisites, and no routing to alternatives such as conditional formatting. Usage is left to inference from the enum names.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the agent knows this mutates spreadsheet state without being flagged destructive. The description adds real context by identifying the feature as the 'basic filter / header row buttons' so the agent knows it is a view-level construct, but it says nothing about whether an existing filter is replaced, whether permissions are needed, or what it returns. Worth noting the mild tension between 'clear' (removes the existing filter) and destructiveHint=false, though a filter is arguably non-destructive metadata.

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

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

A single sentence that front-loads the primary action and appends the alternate mode, with no filler. The parenthetical clarification earns its space by disambiguating the feature.

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

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

With no output schema, the description carries the return burden but the tool's effect is self-evident (filter buttons on/off). Four parameters at 75% schema coverage plus annotations leave only small gaps: no guidance on the required range when clearing and no note about interaction with existing filters.

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 75%, with the range, account and spreadsheet parameters all documented in the schema and the clear flag left bare. The description only implicitly references the clear behavior via 'or clear the tab's filter' and adds no syntax, format, or default information beyond the schema, so baseline 3 applies.

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

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

The description gives a specific verb+resource ('turn on a basic filter for a range') and a second mode ('clear the tab's filter'), and the parenthetical 'filter buttons in the header row' pins down which filter feature is meant versus an advanced filter. No sibling tool in the list touches filters, so differentiation is effectively implicit rather than stated.

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 conveys the two usage modes (set vs. clear), and the schema notes the range argument doubles as a tab name when clearing, which is genuinely useful. However it never states prerequisites (e.g. whether a header row must exist, whether a range is required when clearing) or any when-not condition.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds nothing beyond its title: it does not say that cells are rewritten in place, how formulas/relative references behave after reordering, whether formatting travels with the rows, or that a header row is preserved by default.

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

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

One clear sentence with the verb and scope front-loaded and no filler. Brevity is not the problem here; the sentence is simply carrying too little information for a mutating tool, but that is captured under other dimensions.

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

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

Five parameters, no output schema, and an in-place mutation of user data: the description should cover header handling (has_header defaults to true), whether the range must be contiguous, and what the agent gets back. None of that is present, so an agent must infer the risky parts of the call from the schema alone.

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

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

Schema description coverage is 80%, so the schema already documents range, account, sort_by.column and has_header. The phrase 'by one or more columns' loosely corresponds to the sort_by array but adds no syntax, ordering-priority, or tie-breaking detail, so this sits at the baseline rather than above it.

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

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

States a specific verb (sort) and resource (rows within a range) plus the ordering input (one or more columns). It is understandable on its own, but it does nothing to distinguish itself from siblings such as set_filter, format_range, or batch_update, which could plausibly also be reached for when reshaping sheet 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?

There is no when-to-use guidance at all: nothing says whether this is preferable to filtering (set_filter) or a manual rewrite via write_range, no prerequisites (must the sheet be open, must the account have edit rights), and no warning about when not to call 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?

Annotations only declare the generic safety profile (readOnlyHint=false, destructiveHint=false). The description adds two non-obvious behavioral facts: only values/formulas are restored, not formatting or structure, and the history is in-memory and lost on server restart. That durability caveat is exactly the kind of context annotations cannot carry.

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

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

Two tight sentences, front-loaded with the action and its scope, with the caveat parenthesized where it belongs. No filler.

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

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

For a no-output-schema tool this covers scope and durability well. It omits only edge behavior such as what happens when there is no history to undo, or how many steps are retained, which are minor for selection and invocation.

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

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

Schema description coverage is 100% for both parameters, so the schema already explains account and spreadsheet resolution. The description adds nothing parameter-specific (e.g., whether the undo is scoped per-spreadsheet or per-session), so the baseline 3 applies.

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

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

Specific verb (undo) plus the exact set of operations it reverses (write_range, append_rows, clear_range), which maps directly onto named sibling tools. An agent can distinguish this from every sibling without opening a schema.

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

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

The description scopes usage to writes made 'through this server' and implicitly excludes formatting/structure changes from being undoable, which is meaningful when-to-use context. It stops short of explicitly saying when to prefer it (e.g., immediately after a mistaken write, or that no redo exists).

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorld=true), and the description adds the non-obvious patch semantics that unspecified fields are left untouched. It does not mention permission requirements or what the response looks like, so it is good but not complete.

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

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

Three short sentences: the mutation scope first, then the key behavioral rule, then the id source. Every sentence earns its place with no filler.

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

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

For an 11-parameter mutation tool with no output schema, the description covers the critical unknowns: what changes, what is left alone, and where ids come from. Missing only secondary details like auth/permission notes.

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

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

With 64% schema coverage across 11 parameters, the schema does much of the work, and the description maps its facets onto the parameters (title, type/data_range, stacking, position/anchor, size) and documents chart_id provenance. The remaining parameters (account, has_header, spreadsheet) are only covered by the schema, so it adds value without full compensation.

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

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

States a specific verb and resource ('Change an existing chart') and enumerates the editable facets (title, type, data range, stacking, position, size), which cleanly separates it from add_chart and delete_chart. It stops short of naming those siblings explicitly, so it lands just below the top band.

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?

Gives the crucial partial-update rule ('Only the options you give are changed') and tells the agent where required chart ids originate ('get_spreadsheet_info or add_chart'). No explicit when-not conditions or alternatives are stated, but the context needed to invoke it is clear.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds real value beyond them: previous contents are saved for undo_last, and it returns formula errors found after writing. It still doesn't state permission/account requirements or the overwrite footprint for large ranges (left to the schema's allow_large).

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, each earning its place: anchoring behavior, input parsing model, and undo/error side effects. Front-loaded with the core action and no filler.

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

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

For a destructive 6-param write tool with no output schema, the description covers the key behavioral facts an agent needs: overwrite semantics (undo saved), parses-as-UI input, and formula error reporting. Missing only auth/account and size-limit caveats, which the schema covers at 100%.

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

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

Schema description coverage is 100%, so the baseline is 3; however the description adds parsing semantics not captured in the schema – that values are interpreted as UI input where formulas, dates, and percentages are recognized. That is meaningful extra meaning beyond the field docs.

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

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

States a specific verb (write values and/or formulas) plus the anchoring semantics (starting at the range's top-left cell), which distinguishes it from siblings like append_rows and fill_range. It does not name a sibling explicitly, so it falls just short of a 5.

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

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

Explains how input is interpreted ('parsed like typing into the UI – formulas, dates, percentages work'), which implies usage, but gives no explicit when-to-use/when-not guidance or routing to alternatives such as append_rows or fill_range. Usage is 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.