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

No annotations are provided, so the description carries the full burden. It does disclose a real precondition ('must not already exist' for the title), which is useful behavioral context, but it says nothing about required permissions, whether the operation modifies existing tabs, or side effects of a mutation on a live spreadsheet.

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 core purpose sentence is front-loaded and concise, and the Args block is compact. The structure is slightly padded by the Python-style Args formatting, but no sentence 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?

An output schema exists, so return values needn't be explained, and both parameters are documented. However, for a mutation tool with zero annotation coverage, the lack of permission requirements or effect disclosure leaves a meaningful gap.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it explains spreadsheet_id as 'the long token from the spreadsheet URL' and title as the new tab name with a uniqueness constraint. Both parameters gain meaning beyond the bare schema 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?

States a specific verb and resource ('Add a new tab to an existing spreadsheet'), which cleanly separates it from create_spreadsheet (creates the whole spreadsheet) and the read/write range tools. It stops short of explicitly naming the sibling it contrasts with, but the resource scope is unambiguous.

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

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

The phrase 'existing spreadsheet' implies the prerequisite that the target spreadsheet must already exist, but there is no explicit when-to-use vs create_spreadsheet guidance or list of exclusions. Usage is only implied.

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

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

With no annotations, the description carries the full burden. It usefully discloses the append semantics ('Nothing is overwritten') and the parsing behavior of value_input_option, but says nothing about permissions/auth, what happens if the tab is missing, or error behavior. Partial but meaningful 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?

Front-loaded with the purpose in the first sentence, followed by a tight per-argument list. No filler; the 'Args' block is efficient. Minor formatting roughness but nothing 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?

An output schema exists, so return values need not be explained, and all four parameters are documented despite 0% schema coverage. What remains missing (auth requirements, failure modes) is minor for a straightforward append operation.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: it explains spreadsheet_id ('long token from the URL'), sheet_name with an example, values ('same column order as the sheet'), and the USER_ENTERED vs RAW distinction. This adds substantial meaning beyond the bare schema.

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

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

States a specific verb (append) and resource (rows) with scope ('below the last used row of a tab'). The phrase 'Nothing is overwritten' implicitly contrasts it with write_range, though it never names the sibling. An agent can identify the operation, but the differentiation is left to inference.

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 versus alternatives. The 'Nothing is overwritten' note implies a contrast with write_range but does not say to prefer that tool for overwriting. Usage context is only implied.

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

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

No annotations are provided, so the description bears the full behavioral burden. It partially delivers by disclosing what is destroyed (values) versus preserved (formatting, rows), but says nothing about permissions, irreversibility, or behavior on empty/merged cells, which matters for 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?

One sentence of behavior followed by two terse parameter notes; the effect is front-loaded and nothing is padded.

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?

An output schema exists, so return values need not be described, and the two required parameters are explained. The main gap is that a destructive tool with no annotations omits any note on permissions or reversibility.

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 carry the parameters, and it does: spreadsheet_id is explained as 'the long token from the spreadsheet URL' and a1_range is given a concrete format example. This meaningfully exceeds the bare schema titles.

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 ('Clear the values in a range') and immediately scopes the effect by naming what survives ('leaving formatting and the rows in place'). This lets an agent distinguish it from write_range, which overwrites, 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?

No explicit when-to-use or when-not-to-use statement, and no sibling is named as an alternative. The preservation clause strongly implies the use case (delete content while keeping layout) but the routing is left 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?

With no annotations, the description carries the full burden, and it discloses a genuinely non-obvious behavioral trait: spreadsheets created by a service account are owned by that account, which is why share_with matters. It also declares the return values, though it doesn't cover auth scopes or failure 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?

Purpose and the service-account caveat are front-loaded, followed by a clean Args block for the three parameters. The reflowed multi-line sentence is slightly padded but every sentence 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 creation tool with no annotations, this covers the purpose, all parameters, the ownership caveat, and the return shape (an output schema also exists, so return details are bonus). Missing pieces are modest: auth/permission requirements and behavior on invalid input.

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 largely does: each of the three parameters (title, sheet_names, share_with) is explained, including the non-obvious effect of sheet_names replacing the default tab and share_with granting edit access. It adds little on formats or constraints (e.g., email validation) beyond that.

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

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

States a specific verb+resource ('Create a new spreadsheet') and even names the return payload (ID and URL). It is clear what the tool does, but it never explicitly distinguishes itself from the sibling add_sheet, which also creates a tab and could be confused with the sheet_names parameter.

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 one useful conditional ('pass share_with to give a human account access' when the creator is a service account), which implies usage context. However, there is no explicit when-to-use-this vs. when-to-use-add_sheet guidance, and no prerequisites are stated outright.

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, yet it never states that this is a read-only operation, how no-match or large-result cases behave, or any permission/limit considerations. It does disclose that matching is case-insensitive and that exact=True vs False toggles exact/substring matching, which is a small piece of genuine behavioral detail.

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 first sentence front-loads the purpose and the Args block is tight with no filler. It is appropriately sized for a 7-parameter tool, though the arg list is a plain enumeration rather than prioritized guidance.

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?

An output schema exists, so return-value explanation is not needed, and all 7 parameters are documented. What remains missing is usage routing and any behavioral/safety disclosure, which are the only real gaps for an otherwise well-covered read tool.

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

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

Schema description coverage is 0%, so the description must do all the work, and it does: every one of the 7 parameters is explained, including the meaning of spreadsheet_id ('long token from the URL'), the 1-based indexing of header_row, case-insensitive matching for value, the exact/substring toggle, and limit as a maximum match count. This adds substantial meaning beyond bare JSON 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 gives a specific verb (find) plus resource (records in a tab) and a qualifying predicate (column matches a value), which is enough to distinguish it from a plain bulk reader. It does not explicitly name which sibling to use instead (e.g. read_records vs read_range), so it stops short of full differentiation.

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

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

There is no statement of when to use this tool versus the several reading siblings (read_range, read_records, get_spreadsheet). The usage is only implied by 'find records ... whose column matches a value'; no exclusions or alternatives are 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?

No annotations are provided, so the description carries the full burden. It discloses the return shape (title, URL, tab names/sizes), which is useful, but says nothing about permissions, whether the call is read-only, or rate limits. It is adequate but not rich for a tool with zero annotation coverage.

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 return contents, follows with the usage condition, and ends with a compact Args section. No filler sentences.

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

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

An output schema exists, so return values need not be fully explained, yet the description still previews them. Combined with the parameter provenance and usage trigger, an agent has enough to invoke it correctly; only the absence of behavioral caveats keeps it from a 5.

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

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

Schema description coverage is 0%, but the description explains the single parameter as the 'long token from the spreadsheet URL', which compensates for the missing schema description. With only one parameter and clear provenance guidance, this is 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 (get a spreadsheet) and enumerates exactly what is returned: title, URL, and each tab's name and size. This distinguishes it from siblings like read_range or read_records, which read cell content rather than 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?

Explicitly says to call this before reading when tab names are unknown, which names both the trigger condition and the downstream action. That is a clear when-to-use statement tied to a specific workflow.

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

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

No annotations are provided, so the description carries the full burden. It does disclose access scoping ('credentials can access') and sort order (most recently modified first), which are genuine behavioral facts. However, it omits pagination behavior, total-count limits, and any rate/scope caveats beyond the credential filter.

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 leading sentence is front-loaded and efficient, and the Args section is a clean, scannable breakdown. Formatting is appropriate for the content; minor redundancy is minimal.

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?

An output schema exists, so return-value explanation is unnecessary. For a 2-param, no-annotation list tool, the description is adequate but thin: it lacks notes on pagination, result ordering stability, or empty-result/credential-expiry behavior that would make invocation fully unambiguous.

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 no enums exist, so the schema alone gives no parameter meaning. The description does cover both params with useful semantics (case-insensitive substring; range 1-100, default visible in schema). But it does not clarify interactions, behavior at limit boundaries, or default handling, leaving gaps given the zero-coverage 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 (List) and resource (Google Sheets) plus scope ('credentials can access') and an ordering rule ('most recently modified first'). This distinguishes it from get_spreadsheet and create_spreadsheet siblings, which operate on a single identified spreadsheet.

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 scope 'credentials can access' and the ordering hint imply when to use this (discovery/browsing), but it does not explicitly name alternatives like get_spreadsheet or state when not to use it. Usage is inferable but not spelled out.

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

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

With no annotations provided, the description carries the full behavioral burden but delivers only parameter documentation. It says nothing about auth requirements, rate limits, empty-cell handling, or how values are typed in the response, all of which matter for a spreadsheet read.

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-loaded one-line purpose followed by a compact Args block. Every line earns its place; only the format could be tidied, since the parameter docs live in the description rather than 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?

An output schema exists, so return values needn't be explained, and both params are covered. However, with zero annotation coverage the description omits any behavioral context (permissions, failure modes), leaving the definition minimally viable rather than complete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: spreadsheet_id is explained as 'the long token from the spreadsheet URL' and a1_range is illustrated with three concrete A1 examples ('Sheet1', 'Sheet1!A1:D50', 'Sheet1!A:A'). This is helpful beyond the bare schema 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?

States a clear verb+resource: 'Read a raw grid of cells from a spreadsheet.' The word 'raw' implicitly distinguishes it from read_records, but no sibling is named explicitly, so it stops short of 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 explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The contrast between 'raw grid' and structured siblings like read_records or find_rows is only implied, leaving the agent to infer selection.

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

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

With no annotations, the description carries the full burden. It does disclose a real behavioral trait not in the schema: every record carries a 1-based `_row` field for building A1 ranges. It says nothing about permissions, pagination beyond `limit`, or behavior when header_row is wrong or the tab is empty.

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

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

Purpose is front-loaded in the first sentence, the `_row` note is a genuinely useful second sentence, and the Args block earns its place because schema coverage is 0%. Slightly longer than minimal but 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?

An output schema exists, so return values need no explanation, and all four parameters are documented. What is missing is explicit routing among the many sibling read tools, which is the one gap for an agent choosing between this and read_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 description coverage is 0%, so the description must compensate, and it documents all four parameters. It adds genuine meaning beyond the schema titles: spreadsheet_id is the long token from the URL, sheet_name is the tab name with an example, and header_row is the 1-based row holding headers. Only the `limit` default (200) is left unstated.

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 with a distinguishing qualifier: reads a tab as labelled records keyed by a header row, which separates it in spirit from read_range's raw range read. However, it never names read_range or find_rows explicitly, so sibling differentiation is left implicit.

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 of the `_row` field 'which you can use to build an A1 range for a later update' implies a read-then-update workflow, giving implied usage context. But there is no explicit statement of when to prefer this over read_range or find_rows, and no 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?

No annotations are provided, so the description carries the full burden. It usefully discloses the destructive overwrite behavior ('Existing values are replaced'), which is the most important trait for a write tool, but says nothing about required permissions, whether the range can extend the sheet, error/partial-write behavior, or rate limits.

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

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

Front-loaded with the core operation in one sentence, followed by a tight Args list where every line adds information. 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 mutation tool with no annotations, the description covers the critical destructive behavior and all parameter semantics, and an output schema exists so return values need not be described. Remaining gaps (auth scope, error behavior) are minor.

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, and it largely does: it documents all four parameters, including where spreadsheet_id comes from, the top-left anchoring meaning of a1_range with an example, the row/column nesting of values, and the practical difference between USER_ENTERED and RAW. It stops short of covering edge cases like range/value dimension mismatches, hence not 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?

States a specific verb and resource ('Overwrite a range of cells with the given rows') and clarifies the destructive semantics ('Existing values are replaced'). This cleanly separates it from read_range, append_rows, and clear_range without needing to name 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?

The 'Existing values are replaced' clause implicitly signals this is for replacing content rather than appending, which lightly steers the agent away from append_rows. However, there is no explicit when-to-use/when-not-to-use statement or named alternative, so usage must be inferred.

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