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

With no annotations supplied, the description carries the full behavioral burden, yet it says nothing about this being a read-only operation, authentication/account requirements, error behavior for unknown event_ids, or what happens to the event data. Beyond implying a retrieval, it discloses no behavioral traits.

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 four-word sentence, front-loaded with verb and resource, with no padding or redundancy. Its brevity is clean, though it is arguably under-sized for a tool carrying three parameters and no 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 tool with no annotations, no output schema, three parameters (one required and undocumented), and only 33% schema coverage, the agent is left guessing about the identifier's origin, the default calendar, and account selection. The description is far too thin to be complete.

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

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

Schema coverage is only 33%: the schema documents only 'email', while 'event_id' (required) and 'calendar_id' are bare. The description adds nothing about the required identifier's format/source or about calendar_id defaulting behavior, so it fails to compensate for the documented gaps.

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

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

The description pairs a specific verb ("Fetch") with a specific resource ("a single event"), and the word "single" implicitly distinguishes it from the sibling calendar_list_events. It is clear what the tool does, though it never names the sibling or the scope boundary explicitly.

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 calendar_list_events (which is presumably how you obtain an event_id) or any other sibling. No prerequisites are stated, such as needing an event_id that must first be discovered via listing or search.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether this is a read-only operation, whether shared/subscribed calendars are included, whether results are paginated, or what the response contains — for a tool with zero annotation coverage this is a real 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 with no filler, which is appropriate for a simple list operation. It is arguably under-specified rather than padded, so terseness here is a mild virtue rather than a flaw.

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 one-parameter read tool with full schema coverage the description is minimally viable, but with no annotations and no output schema an agent still lacks the safety profile and return-shape context it would want. Adding one clause about read-only semantics and the email requirement would close the 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 coverage is 100% and the single optional email parameter is well documented in the schema, including the condition for when it is required. The description adds nothing beyond that, which is the expected baseline when the schema does the heavy lifting.

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 (the user's calendars), so the operation is unambiguous. It does not, however, explicitly distinguish itself from the closely named sibling calendar_list_events, leaving the agent to infer that this returns calendar containers rather than events.

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 guidance on when to call this versus calendar_list_events, nor any prerequisite context such as needing a configured account first (setup_list_accounts/setup_add_account exist as siblings). 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?

No annotations are present, so the description carries the full behavioral burden and mostly fails it. It discloses only the calendar_id default; it says nothing about pagination via page_token, max_results default, recurring-event expansion, account/auth requirements, or the read-only nature 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 tight sentences with the core action front-loaded and no filler. It is appropriately sized for readability, though arguably too terse for an 8-parameter tool.

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 list tool with no annotations and no output schema, the description omits critical context: pagination, default result limits, recurring-event behavior, and the account-selection semantics. It is far from complete enough to call the tool correctly without opening the schema.

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

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

Schema coverage is 63%, with the undocumented params (page_token, calendar_id, max_results) left ambiguous in the schema. The description usefully supplies the calendar_id default of 'primary', which the schema lacks, but adds nothing for the other gaps, so it stays at 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 ("List events on a calendar") plus a scoping constraint ("in a time window"), which cleanly separates it from calendar_get_event. It does not, however, explicitly name the sibling it differs from, 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 description gives no when-to-use or when-not-to-use guidance and never mentions alternatives like calendar_get_event for a single event or calendar_list_calendars for discovery. Only a scoping hint ("time window") implies usage, leaving an agent to infer routing.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the return format (structured Docs API document) and the default tab-inclusion behavior, but says nothing about the read-only nature, authentication requirements tied to the email parameter, or any size/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?

A single sentence with zero waste, and the key differentiator (structured API document, all tabs) is front-loaded. Nothing to trim.

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 annotations and no output schema, the description is minimally adequate but leaves gaps: it never explains the email/account requirement or how this tool relates to the similarly named docs_read_document sibling.

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 baseline is 3 and the schema already documents all three parameters. The phrase 'including all document tabs by default' loosely mirrors the include_tabs_content default, but the description adds no syntax or format 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?

States a specific verb ('Fetch') and resource ('Google Doc') and even specifies the return shape ('full structured Google Docs API document'), which is more than most definitions offer. However, it does not differentiate itself from the sibling tool docs_read_document, so an agent cannot tell the two apart from the description alone.

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 when-to-use or when-not-to-use guidance is given, and no alternative is named. The existence of a close sibling, docs_read_document, makes this omission costly: nothing in the description tells the agent which of the two read tools to pick.

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

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

With no annotations, the description carries the full burden, and it does disclose the return shape (plain text per tab, combined text, metadata, tables rendered as TSV rows), which is genuinely useful. However it says nothing about authentication/account selection, rate limits, large-document truncation, or error behavior for inaccessible docs.

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 the core action and then the return format. Every sentence carries information; nothing is padding.

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

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

Since there is no output schema, the description usefully compensates by describing the returned text structure and TSV table rendering. It is still incomplete regarding the multi-account email requirement (only covered in schema) and failure modes, which it leaves to the 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 both parameters (email, document_id_or_url) are fully documented in the schema. The description adds no parameter-level detail beyond that, 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?

States a specific verb and resource ('Read the text of a Google Doc') and scopes the output precisely (per-tab text, nested tabs, combined text, metadata, tables as TSV). It never distinguishes itself from the sibling docs_get_document, so an agent must infer which of the two returns raw text versus 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?

There is no when-to-use guidance, no statement of alternatives (docs_get_document, drive_read_file), and no prerequisites such as which account or permission is needed. Usage is only implied by the verb 'Read'.

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

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

With no annotations, the description carries the full burden, and it does disclose real behavior: native Workspace files are auto-exported with stated default formats, and export_mime_type overrides that. It is silent on authentication requirements, overwrite behavior when dest_path already exists, and rate/size limits on downloads.

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 core action and destination front-loaded, followed immediately by the one non-obvious behavior (native file export). 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?

There is no output schema, so the description should ideally say what the call returns (e.g., the written path) and whether an existing file is overwritten. It covers the download and export semantics adequately but leaves these operational details unspecified.

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 adds genuine meaning for export_mime_type by explaining the default export mapping that applies when it is omitted, but adds nothing for email, dest_path, or file_id_or_url 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 pairs a specific verb (download) with a specific resource (Drive file) and a destination constraint ('to an exact local path'), which separates it from read-style siblings like drive_read_file and drive_get_file. It stops short of naming any sibling explicitly, so the differentiation is inferable 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?

Usage is implied by the export rule: use export_mime_type only when you need a non-default format for a native Workspace file. There is no explicit when-to-use/when-not guidance and no mention of when to prefer drive_read_file over downloading.

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 disclosure burden, and it delivers essentially none. "Get" implies a safe read, but there is no statement about permissions/auth requirements, what happens with invalid IDs, or the shape of the returned metadata. One sentence of pure intent is thin 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?

A single front-loaded sentence with no filler, restatement of the name, or hedging. Every word earns its place, though brevity here partly reflects under-specification rather than disciplined editing.

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 or annotation set, so the description bears the responsibility for behavioral and return context, and it does not specify what metadata is returned (size, mimeType, permissions, parents). For a simple two-parameter read tool with a fully documented schema, it is adequate but 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?

Schema description coverage is 100%, so both parameters are already documented, and the baseline is 3. The description adds only marginal value by naming the resource types (file, folder, shortcut), while the schema's own text also covers file/folder ID vs URL, so it does not meaningfully extend parameter meaning.

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 ("Get") plus resource ("detailed metadata for a Google Drive file, folder, or shortcut"), and "metadata" implicitly separates it from content-oriented siblings like drive_read_file and drive_download_file. It does not name those siblings explicitly, so the differentiation is inferred 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?

The description states what the tool returns but gives no when-to-use guidance, no conditions selecting it over drive_read_file, drive_search_files, or drive_list_folder, and no exclusions. The agent must infer the routing decision from the tool names alone.

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 must carry the behavioral burden. It usefully discloses that only DIRECT children are returned (non-recursive) and that both My Drive and shared drives are supported, but says nothing about pagination behavior, permission requirements, or that this is a read-only listing.

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

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

Three compact sentences, front-loaded with the core action, and each sentence contributes (result composition, scope, root default). No filler or repetition.

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

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

For a 9-parameter, zero-required read tool with no output schema and no annotations, the description covers the essentials: what is listed, what is included, supported corpora, and the root default. The main gap is pagination/enumeration behavior, which the schema only partially implies.

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 89%, so the schema already documents nearly every parameter including defaults and bounds. The description adds only the root-default behavior for folder_id_or_url, which is meaningful but exceeds the baseline by little.

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 ('List the direct children of a Google Drive folder') and clarifies the result includes folders, files, and shortcuts. It does not explicitly name or differentiate itself from the sibling drive_search_files, but the scope statement 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?

Tells the agent that omitting folder_id_or_url lists My Drive's root, which is useful operational context, but offers no when-to-use/when-not guidance and never mentions the sibling drive_search_files as the alternative for querying by content. Usage is implied rather than 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?

No annotations are provided, so the description carries the full burden. It implies a read-only listing but says nothing about pagination behavior, permission/auth requirements, result limits, or what happens when the account has no shared drives. For a zero-annotation tool this leaves significant behavioral gaps.

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 wasted words. The verb and resource lead the sentence and the scope qualifier 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 annotations, no output schema, and four parameters, the description is too thin. It omits pagination semantics, the shape of the returned drives, and how the account selection interacts with the email parameter, which an agent needs to call this correctly in a multi-account setup.

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%, so most parameters (email, query, page_size) are already documented in the schema, and the description adds no parameter-level detail. Baseline 3 applies since the schema does the heavy lifting and page_token has no description anywhere.

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 (shared drives) with a scoping qualifier (the selected Google account can access), so an agent can distinguish it from siblings like drive_list_folder or drive_search_files. It does not explicitly name alternatives, but the resource 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?

No when-to-use guidance or comparison against alternatives such as drive_search_files or drive_list_folder. The phrase 'selected Google account' weakly implies the email parameter context, but nothing tells the agent when this tool is the right choice versus another drive listing/search tool.

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

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

With no annotations, the description carries the full burden. It does disclose a genuinely useful, non-obvious trait: native Docs/Sheets/Slides are exported to plain text/CSV by default, so the agent knows the return format is transformed rather than raw. It omits permissions/auth requirements, error behavior, and any limits, so it is only partially transparent.

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

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

Three tight sentences, front-loaded with the core action and followed by the two facts that change agent behavior (export default and the binary alternative). 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?

No output schema and no annotations, so the description must stand alone; it adequately covers what the tool reads and what format it returns. It stops short of covering auth requirements or failure modes, but for a read tool with fully documented params this is close to 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 100%, so all four parameters are already documented in the schema (email fallback behavior, file_id_or_url, max_characters default, export_mime_type). The description adds no syntax or format detail beyond implying the export default, 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?

States a specific verb and resource ('Read a text file from Google Drive') and immediately names the sibling it is not for binary content ('drive_download_file'). An agent can tell this apart from the download path 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?

Gives a clear exclusion ('Binary files should be saved with drive_download_file instead'), which routes the agent correctly for the binary case. It does not, however, distinguish this from drive_get_file or the docs_/sheets_ readers, so sibling ambiguity remains for text-like workspace files.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that results span My Drive and shared-drive items, but omits whether this is read-only, how pagination works (page_token/page_size exist in schema), and what a result contains.

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, purpose front-loaded, examples inlined compactly with no wasted words. Nothing can be trimmed 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?

The rich schema covers parameters, but with no annotations and no output schema the description should say more about behavior and return shape. It explains the core query mechanism but leaves the agent guessing about result format and pagination behavior.

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 88%, so the schema already documents nearly all parameters, giving a baseline of 3. The description adds query-string examples and scope relevant to the corpora parameter, but says nothing extra about email, order_by, page_token, or include_trashed.

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 ('Search') and resource ('Google Drive files and folders') and pins the mechanism with query-syntax examples, making it distinguishable from siblings like drive_list_folder (browse one folder) or drive_get_file (fetch one file). Scope ('Includes My Drive and shared-drive items') further separates it from single-corpus tools.

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

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

Usage is implied by the query-syntax examples, but there is no explicit when-to-use/when-not guidance and no reference to alternatives such as drive_list_folder for simple browsing. The examples hint at scenarios without stating them.

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 the significant side effect of writing files to disk and the exact artifact layout, which is valuable. However, it says nothing about authentication requirements, rate limits, or how partial failures mid-export are handled, which for a bulk mutation tool is a notable 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?

Two tight sentences with zero filler, and the primary purpose is front-loaded before the output layout detail. Every sentence 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?

There is no output schema, so the description must cover return values, and it does so precisely by describing the per-message directory, the named files, and the index.json summary. It falls short only on error/partial-completion behavior and auth expectations for a tool that writes to an arbitrary absolute path.

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 six parameters (including defaults for max_messages, include_html_body, include_attachments, and the email account-selection rule) are already documented in the schema. The description adds no syntax or format detail for these parameters 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?

States a specific verb (bulk-export), resource (messages), scoping mechanism (matching a Gmail search query), and destination (a directory). This clearly separates it from gmail_search and gmail_download_attachments, which an agent can distinguish 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?

The word "bulk" and the query-matching framing imply when this tool is appropriate versus a single-message sibling, but the description never states when-not to use it or names an alternative for non-bulk retrieval. Usage is inferable but not explicit.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the output naming scheme (`<messageId>__<originalFilename>`) and collision avoidance, but omits any statement about overwriting existing files, duplicate handling, size/rate limits, or whether the Gmail mailbox itself is left untouched (read-only side effects vs. disk writes).

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, front-loaded with the core action and scope. The naming-convention detail and the return-value note both earn their place given there is no output schema.

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

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

For a six-parameter write-to-disk tool with no annotations and no output schema, the description leaves gaps: the shape of the returned 'summary' is undefined, and side-effect semantics (overwrite, dedup) are unstated. Adequate but with clear holes.

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 six parameters are already documented in the schema. The description adds no parameter-level detail (e.g., query syntax beyond the schema example, filter semantics, or max_messages defaults), 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?

States a specific verb and resource ('Download attachments from messages matching a Gmail search query into a destination directory') plus the naming convention used for output files. The purpose is unambiguous, but it does not distinguish itself from the nearby sibling gmail_bulk_export, which an agent may confuse it with.

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 never says when to prefer this tool over alternatives such as gmail_search, gmail_get_message, or gmail_bulk_export. There is no mention of prerequisites (configured account), no exclusions, and no guidance on choosing between attachment-downloading flows.

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 only says it fetches full content. It does not disclose authentication requirements, error behavior, or what 'full content' includes.

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 single, front-loaded sentence with no wasted words. It is appropriately concise for a simple getter tool.

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

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

For a tool with no annotations, no output schema, and only 50% schema parameter coverage, the description leaves key gaps. It omits usage guidance, parameter meaning, and behavioral context, making it insufficiently complete for reliable 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 only 50%, and the description adds no parameter information to compensate. The required id and optional email parameters are left entirely to the schema, with the latter only partially documented.

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

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

The description clearly states a specific verb and resource: fetching a draft's full content. It is easy to understand what the tool does, though it does not explicitly differentiate itself from siblings like gmail_get_message or gmail_list_drafts.

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 such as gmail_get_message or gmail_list_drafts. It also omits any prerequisites, such as whether a draft id must be obtained first.

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 helpfully says the response includes headers and decoded text body, but omits authentication/account requirements, error behavior, and how the format parameter changes output.

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 states the verb, resource, identifier, and return content without wasted words.

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

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

No output schema or annotations exist, so the description should carry more context. It gives some return information, but does not explain account selection, format effects, or permission requirements for a read tool with three parameters.

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

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

Schema coverage is 67%, with the schema describing email and format. The description covers the required id parameter but adds no semantics for email or format, so it does not materially compensate for the remaining gap.

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

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

The description states a specific verb (Fetch), resource (single Gmail message), identifier (by ID), and returned content (headers and decoded text body). It implicitly distinguishes 'message' from siblings like gmail_get_thread or gmail_get_draft, but does not explicitly name alternatives or boundaries.

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 implied: call this when you have a message ID and need the message content. There is no explicit when-to-use, when-not-to-use, or alternative routing, such as when to prefer gmail_get_thread or gmail_search.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the return trait that matters most (all messages, in order), which is useful and not derivable from structured fields, but it omits the read-only nature of the operation, any permission/account prerequisites, pagination or size limits, and behavior for an invalid thread ID.

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: verb, resource, identifier, and scope. Nothing is repeated from the structured fields and nothing needs trimming.

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 two-parameter read tool with no output schema, the description covers the essential action and roughly what comes back. It leaves the returned message structure to guesswork and omits sibling differentiation, so it is adequate but with visible gaps.

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

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

Schema description coverage is 50%: the optional email parameter is fully documented in the schema, while id is undocumented there but implicitly explained by 'by ID' in the description. That is a marginal add for the id parameter, not substantial compensation, 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?

Specific verb (fetch) plus resource (Gmail thread) and scope (entire thread, all messages in order). It clearly tells an agent what the tool returns, but it never distinguishes itself from the sibling gmail_get_message, which is the natural source of confusion for an agent choosing between thread-level and message-level retrieval.

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 when-to-use, when-not-to-use, or alternative is given. With gmail_get_message and gmail_search in the sibling list, the description should state that this retrieves a whole conversation when the thread ID is known, but it offers no routing guidance at all.

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 disclosure burden, yet it only states result ordering. It says nothing about pagination behavior (despite a page_token parameter), auth/account requirements, or rate limits, leaving an agent to discover these at call time.

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 short sentence with the core action front-loaded and zero filler; it is efficiently structured, though arguably terse to the point of under-specification.

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 annotations, no output schema, 33% parameter coverage, and a paginated list operation whose pagination is never explained, the definition leaves significant gaps an agent would need to resolve before calling 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 description coverage is 33% — only 'email' is documented, while 'page_token' and 'max_results' (with its 1-100 bound) are bare in the schema. The description adds no parameter meaning at all, so it fails to 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?

The description gives a clear verb+resource ('List Gmail drafts') and adds ordering semantics ('most recent first'), which distinguishes it from gmail_get_draft (single draft). However, it makes no attempt to distinguish itself from the broader sibling set (gmail_search, gmail_list_labels), so it stops short of full 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?

There is no when-to-use guidance, no exclusions, and no mention of alternatives such as gmail_get_draft or gmail_search. Usage is only inferable from the tool name itself, which is exactly the kind of inference a description should eliminate.

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

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

There are no annotations, so the description carries the full behavioral burden, and it discloses almost nothing: no statement that it is a read-only operation, no auth/account requirements, no pagination or rate-limit notes. Only the scope hint ('system and user') goes beyond the name, which is thin for an unannotated tool.

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

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

A single front-loaded sentence with zero filler that states the action and the scope; nothing is wasted and nothing important is buried.

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

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

For a simple one-parameter read tool with full schema coverage and no output schema, the description is minimally adequate. However, with no annotations it still leaves the read-only nature, account-selection behavior, and return shape unstated.

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% and the single 'email' parameter is fully documented in the schema, including the single-vs-multiple account rule. The description adds no parameter meaning beyond that, 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?

States a specific verb (list) and resource (Gmail labels) plus the scope (system and user), so an agent immediately knows what it returns. No sibling tool lists labels, so there is no sibling to differentiate against, which is the only thing keeping this from 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 gives no when-to-use guidance, prerequisites, or alternatives. It never states that this is a discovery tool typically called before operations that need label IDs, so the agent must infer the usage context entirely.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses that the default path performs per-message header fetches and that 'ids' skips them (a real cost/latency trait), but says nothing about auth requirements, page limits, rate limits, or result ordering.

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 core purpose and default return shape front-loaded and the format alternative second. 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 no output schema, the description correctly compensates by enumerating the returned fields (from/subject/date/snippet/labelIds/hasAttachments) and the alternate shape. Pagination cursor and max_results are covered by the schema, so the remaining gap is 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 description coverage is 100%, so all five parameters (including the format enum and account-selection rules for email) are already documented. The description reinforces the format tradeoff but adds no syntax, query-language, or default detail beyond the schema, matching the baseline for full coverage.

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

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

States a specific verb and resource ("Search Gmail") and immediately characterizes the default return payload. It signals a routing relationship to bulk operations but never names the sibling tools (gmail_get_message, gmail_get_thread, gmail_bulk_export) it should be chosen over.

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 conditional guidance for the format parameter ("Set format='ids' for the lighter ID-only response... useful for piping to bulk ops"), which implies a workflow but not a tool-selection rule. There is no explicit when-to-use-this-vs-alternatives statement for the search itself.

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

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

With no annotations, the description carries the full burden and does well: it discloses the interactive two-call handshake, what the first call returns (a consent URL), and a genuine side effect — that all Google tools then require email on every call. It stops short of stating permission scopes, token persistence, or what happens if the consent URL is never completed.

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, zero filler, ordered by the sequence an agent will actually execute. The downstream email requirement is placed last where it reads as a consequence rather than competing with the core instruction.

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

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

For a zero-required-param, no-output-schema setup tool, the description covers the flow, the return value of step one, and the cross-tool consequence. Only failure/abort behavior and account-limit details are absent, which are minor for this 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 100%, so the baseline is 3, and the description adds real value by clarifying the state-dependent meaning of url_or_code (omit to start, pass localhost URL or bare code to finish) and noting email's preselect/verify role. This is more than a restatement of 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?

Specific verb+resource ('Authorize an additional Google account') with a clear scope qualifier ('additional') that separates it from setup_auth and setup_list_accounts, which are the nearest siblings. An agent can pick this tool 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?

The two-phase usage is spelled out precisely: call without url_or_code to obtain a consent URL, then call again with the post-consent localhost URL/code. The word 'additional' implies setup_auth handles the first account, but the alternative is never explicitly named and no when-not-to-use condition is given.

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 and does well: it discloses the two-phase consent flow, the exact scopes requested (Gmail, Calendar, Docs/Sheets read/write, Drive read-only), and that existing accounts must reauthorize to pick up newly added scopes. It does not say whether a browser is launched or where tokens are persisted, which are the only notable gaps.

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 with no filler, and the actionable two-step protocol is front-loaded before the scope inventory. Every sentence carries distinct information (flow, scopes, reauthorization caveat).

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 annotations and no output schema, the description must cover behavior itself, and it does: both phases are described and the consent URL return is implied by 'receive a consent URL.' It could be more complete about the completion-state response (e.g., which account was signed in), but nothing critical is missing.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, and the description largely restates the same protocol (omit `url_or_code` to start, pass the URL/code to finish). The `email` preselect/verify semantics live only in the schema, not the description, so no value is added beyond the 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: authorize (or reauthorize) a Google account, and names the two modes (first account vs. existing account). It is clearly distinct from the read-only gmail_*/drive_* siblings, but it never distinguishes itself from setup_add_account, leaving an agent to guess which of the two setup tools actually adds an account.

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

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

Explicitly states the calling protocol: call without `url_or_code` to begin, then call again with the post-consent localhost URL/code to finish. That is actionable context an agent can follow directly. It stops short of naming an alternative or exclusion (e.g., when to use setup_add_account instead).

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, but "List" conveys read-only semantics and it usefully discloses what is returned (accounts plus granted scopes). It says nothing about auth requirements, whether scopes reflect live grants, or pagination/error 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 that states the resource and the returned content with no filler. Every word 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 zero-param read tool with no output schema, the description covers the essential return content (accounts and their scopes). Given no annotations exist, a touch more on read-only safety or prerequisites would fully close the 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?

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline for a no-arg tool applies. The description adds nothing misleading in this dimension.

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 ("configured Google accounts and their granted OAuth scopes"), which is unambiguous. It doesn't name or route against siblings like setup_auth or setup_add_account, but the resource itself is distinct enough that an agent can differentiate it.

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 would infer this is the way to enumerate existing accounts. There is no explicit when-to-use, no prerequisite (e.g. run setup_auth first), and no mention of how it relates to setup_add_account.

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

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

With no annotations, the description carries the behavioral burden and does disclose key traits: grid data is off by default, enabling it returns formatting, and range restriction mitigates large-spreadsheet cost. It stops short of stating auth requirements or account-resolution behavior (which the schema covers for email).

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 what the tool returns, followed by default-behavior and discovery guidance. No filler; every sentence carries actionable 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?

There is no output schema and no annotations, so the description is the main source of truth, and it covers return contents, the grid-data default, and ID discovery adequately. Auth/permission behavior is the only notable gap, which the email parameter description partially offsets.

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%, so the schema already documents each parameter thoroughly (including the URL/gid caveat and email rules). The description adds only a light performance rationale for 'ranges' and the formatting motive for grid data, so it sits at the high-coverage baseline of 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 ('Get') and resource ('spreadsheet') and enumerates exactly what is returned: metadata, tab titles/IDs, dimensions, named ranges. The scope note that cell grid data is excluded implicitly separates it from sheets_read_values, so an agent can distinguish it from siblings 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?

Gives clear operational guidance: enable grid data only for formatting needs, restrict ranges for large spreadsheets, and discover IDs via drive_search_files with the specific mimeType filter. It lacks an explicit 'use sheets_read_values instead when you need cell values' exclusion, but context for when to reach for this tool is solid.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses output ordering and trimming ('valueRanges in requested order, with trailing empty rows/columns omitted'), but says nothing about read-only safety, permission/scope requirements, or quota behavior for a read tool.

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

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

Three tight sentences: purpose and scope first, then return behavior, then the most consequential parameter choice. Every clause carries information and nothing is repeated from 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?

With no output schema, the description appropriately describes the return value ('valueRanges in requested order' with trimming). The remaining parameters (major_dimension, date_time_render_option) are documented in the schema, so coverage is adequate, though a note on multi-account/auth context could help given the email parameter.

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

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

Schema coverage is already high at 83%, so baseline is 3. The description goes beyond the schema by explaining the practical meaning of the value_render_option choices ('inspect formulas' vs 'calculated numbers'), which the enum alone does not convey, earning a modest bump.

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 one or more ranges across spreadsheet tabs') and adds a distinguishing scope detail: multiple ranges in one request. It doesn't explicitly contrast with the sibling sheets_get_spreadsheet, so it stops short of a 5, but an agent can tell what this does 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?

The only guidance is value_render_option semantics ('Choose FORMULA to inspect formulas or UNFORMATTED_VALUE for calculated numbers'), which is parameter-level, not tool-level. There is no statement of when to prefer this over sheets_get_spreadsheet or any prerequisites, leaving usage largely implied.

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