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

Beyond the annotations (readOnly=false, openWorld=true), the description reveals key behaviors: it opens the browser, returns a pendingId, and requires polling the complete function. It also notes that each account stores its own credentials, which is a stateful detail not in the annotations.

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

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

The description is four sentences, each adding critical information: purpose, OAuth flow with pendingId, credentials storage, and org-specific configuration. No wasted words, and the main verb is front-loaded.

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

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

The description covers the complete add-account flow, including the async nature, browser interaction, and follow-up poll step. It doesn't mention error cases or timeouts, but given the clear workflow and the schema's parameter descriptions, it is sufficient for an AI agent to invoke it correctly.

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

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

The schema already documents all three parameters with descriptions, so the baseline is 3. The description adds context for clientId/clientSecret by noting that different organizations need their own credentials from that org's GCP project, which clarifies when these optional parameters matter.

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

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

The description clearly states the tool's function: 'Connect a new Google account via OAuth.' This specific verb+resource combination distinguishes it from siblings like reauth or remove, and the mention of gws.accounts.complete clarifies the workflow.

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

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

It provides explicit guidance to call gws.accounts.complete to finalize the pending OAuth flow, and explains that different organizations require their own clientId/clientSecret from their GCP project. However, it doesn't explicitly say when to use reauth instead of add, though 'new account' implies it.

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

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

Beyond the annotations (readOnlyHint=false, openWorldHint=true, etc.), the description reveals the non-blocking behavior, the pending status, and the need to poll. This adds valuable context about how the tool actually behaves.

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, front-loaded with the main purpose, then the key behavioral note. No unnecessary words 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 simple two-parameter tool with no output schema, the description adequately explains the flow, the polling behavior, and the relationship to sibling tools. It is complete enough for an agent to invoke 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 100%, so the baseline is 3. The description itself does not add significant parameter details beyond what the schema already provides; it reinforces the purpose of pendingId but adds no new semantic information.

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

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

The description clearly states the tool finalizes a pending OAuth flow initiated by two specific sibling tools (gws.accounts.add and gws.accounts.reauth). This uses a specific verb and resource, and distinguishes it from the flow-starting tools.

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

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

It explicitly references the flow starters and explains the expected calling pattern: returns quickly, may return 'pending', and the caller should call again. This is clear when-to-use guidance with polling behavior described.

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

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

The description adds context about the output (labels and default status) beyond the readOnlyHint and destructiveHint annotations. However, it does not disclose any additional operational behavior such as pagination, sorting, or error conditions. With annotations already establishing the read-only nature, the description adds moderate value.

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 sentence of 12 words, front-loaded with the verb 'list' and the resource. Every word contributes meaning, with no fluff 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 zero-parameter list operation with clear annotations and distinct sibling tools, the description fully covers what the tool does and what it returns. Although there is no output schema, the description explicitly mentions the return content ('labels and default status'), making it complete for a tool of this complexity.

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

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

The tool has zero parameters, so the schema is fully covered by default. The description appropriately does not attempt to explain parameters; it would have been redundant. This aligns with the baseline for parameterless tools.

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

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

The description uses a specific verb 'list' with a clear resource ('connected Google Workspace accounts') and specifies the returned details ('labels and default status'), clearly distinguishing it from account mutation tools like gws.accounts.add or gws.accounts.remove.

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: you would use this tool when you need to see all connected accounts. However, the description does not explicitly mention when to use it over alternative tools, nor does it provide any exclusions or prerequisites.

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

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

The description adds significant behavioral detail beyond annotations: it discloses that the tool opens a browser, returns a pendingId, and requires a follow-up call to complete. It also clarifies that it does not change account label or settings, providing useful boundary information.

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

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

The description is two sentences, front-loaded with the main purpose, then explains the asynchronous flow and non-destructive nature. Every sentence adds value without redundancy.

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

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

Given the async browser-based flow, the description properly instructs the agent to expect a pendingId and call gws.accounts.complete. It also covers what the tool does not do (changes to label/settings). No output schema exists, but the return value is mentioned.

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%: the single parameter 'account' is fully described as 'Account label or email to re-authorize.' The tool description repeats this without adding new parameter-level meaning, so a baseline score of 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?

The description clearly states the tool's purpose: 'Re-authorize an existing account.' It uses a specific verb and resource, and it distinguishes itself from siblings like gws.accounts.add (new account) and gws.accounts.complete (finalization) by explaining the re-auth flow.

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

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

Provides clear context on usage: opens the browser, returns a pendingId, and explicitly instructs to call gws.accounts.complete to finalize. However, it does not explicitly state when not to use this tool versus alternatives, such as for adding a new 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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds specific context by stating that tokens are deleted, which clarifies the exact destructive impact beyond the generic annotation.

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, concise sentence that front-loads the core action and outcome. Every word earns its place with zero 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?

This is a simple tool with one parameter, full schema coverage, and annotations that already indicate destructive behavior. The description adds the key detail of token deletion, making the total context sufficient for an agent to understand the operation and its consequences.

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

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

The input schema has 100% coverage for the sole parameter 'account' with a clear description 'Account label or email to remove'. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

The description 'Disconnect a Google account and delete its tokens' uses a specific verb and resource, clearly distinguishing this from siblings like add, list, reauth, and set_default. It leaves no ambiguity about the tool's function.

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 does not explicitly state when to use this tool or mention alternatives. Usage is implied by the tool name and the action described, but there is no guidance on when to prefer this over e.g. `reauth` or `set_default`.

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

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

Annotations already indicate this is not read-only (readOnlyHint=false), so the write nature is known. The description adds the behavioral nuance that the default applies when no account is specified, but does not disclose persistence, error behavior, or broader side effects, which would be valuable for a state-changing 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 precisely states the tool's function without waste. 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 simple one-parameter tool with no output schema and clear sibling context, the description is sufficient. It could benefit from mentioning whether the default is persistent or session-scoped, but the current wording is adequate for basic selection and invocation.

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

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

The schema covers 100% of the parameter (account) with a clear description, so the baseline is 3. The tool description adds no additional parameter detail beyond what the schema already provides.

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

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

The description uses a specific verb+resource ('Set the default account') and clarifies the scope ('used when no account is specified'). It clearly distinguishes from sibling tools like add, remove, and reauth, which serve different purposes.

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

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

The description implies when to use it (when you want to set a default account) but provides no explicit guidance on alternatives or exclusions. Sibling names are distinct, so context helps, but there is no direct 'use this instead of X' statement.

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

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

The description adds value beyond annotations by explaining the return value (event ID and link), the requirement for RFC3339 timestamps with timezone offset, and the user confirmation step. Annotations already indicate mutation, but the description enriches the behavioral expectations.

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

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

Four concise sentences, each providing essential information without redundancy. The description is well-structured and easy to parse.

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 seven parameters and no output schema, the description covers the key aspects: action, return value, timestamp format, calendar default, and user interaction requirement. It is complete enough for an agent to invoke 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 covers all parameters, but the description adds meaning: it clarifies that start/end must include timezone offset in the RFC3339 format, and explains the default behavior of calendarId. This goes beyond the schema's terse field descriptions.

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

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

The description clearly states the tool creates a calendar event on the account's calendar, using the verb 'create' and specifying the resource. It also distinguishes from sibling tools like get_event and list_events by focusing on creation and mentioning return of the event ID and link.

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

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

Provides clear context on default calendar behavior (primary unless calendarId given) and instructs to preview details with the user before calling. It does not explicitly name alternative tools, but the guidance is sufficient for typical use cases.

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

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

The description goes beyond the annotations (destructiveHint=true, readOnly=false, idempotent=false) by adding important behavioral details: it 'removes the event for all attendees and cannot be undone,' which explains the scope and irreversibility. It also discloses the return value ('Returns the deleted event's ID and calendar'), which is absent from annotations. No contradictions with annotations.

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

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

The description is concise and front-loaded, starting with the primary action. Each sentence adds value: canceling, default calendar, irreversibility/safety, and return value. No unnecessary words 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 destructive tool with no output schema, the description is complete: it covers purpose, default behavior, irreversible impact, safety confirmation, and what gets returned. It sufficiently prepares an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, with each parameter (account, eventId, calendarId) having a clear description. The description adds minimal new parameter semantics; it repeats the default primary calendar behavior already stated in the calendarId schema description. Therefore, the baseline score of 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?

The description clearly states the tool's purpose with a specific verb and resource: 'Delete (cancel) a calendar event.' It also distinguishes from sibling tools like create_event, update_event, and get_event by emphasizing deletion and cancellation. The addition of 'Defaults to the primary calendar unless calendarId is given' further clarifies scope.

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

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

The description provides clear usage context, including the default calendar behavior and the requirement to confirm with the user before calling (a safety guideline). However, it does not explicitly name alternative tools for non-destructive modifications, so it lacks explicit when-not-to-use guidance. This fits 'clear context, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds useful behavioral context: it returns busy intervals per calendar or indicates free-for-the-range, and defaults to primary calendar unless calendarIds is given. This goes beyond the annotations.

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

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

The description is three sentences, front-loaded with the core purpose, and every sentence adds value. No fluff 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 read-only query tool with 100% schema coverage and no output schema, the description is complete enough. It explains the return format (busy intervals per calendar), defaults, and use case. The only minor gap is not explaining how to interpret the response for free slots, but the description's final sentence covers the intent.

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 parameters are documented in the schema. The description adds context about timeMin/timeMax being RFC3339 timestamps and the default behavior of calendarIds, but this is largely redundant with the schema. 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?

The description clearly states the tool queries free/busy status for calendars over a time range, with specific details about defaults and return values. It distinguishes itself from sibling calendar tools like list_events and create_event by focusing on availability checking.

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

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

The description provides clear context for when to use this tool ('Use this to find open slots before scheduling') and explains the default behavior. It doesn't explicitly mention when not to use it or name alternatives, but the purpose is distinct enough among siblings.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds no additional behavioral context beyond 'full details' — it does not mention required identifiers, return structure, or any side effects. No contradictions with annotations.

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

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

The description is a single, compact sentence that directly states the tool's purpose without extraneous words or repetition. It is well-structured and immediately understandable.

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 read-only tool with no output schema and high schema coverage, the description is sufficient. It clearly indicates the function (get full details) and context is implied by the resource type. It could benefit from noting that an eventId is required, but that is already in the schema, so the description remains complete enough.

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%, with all three parameters (account, eventId, calendarId) having clear descriptions. The tool description does not add further parameter-level meaning, so the schema carries the load. 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?

The description 'Get full details of a calendar event' uses a specific verb ('Get') and resource ('calendar event'), clearly indicating it retrieves detailed information for a single event. This distinguishes it from sibling tools like gws.cal.list_events (which lists events) and gws.cal.create_event (which creates 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?

The description implies usage for retrieving full details of a calendar event, but does not explicitly state when to use it over alternatives or provide context such as needing an eventId from a list operation. The distinction from siblings is not spelled out, so guidance is implied rather than 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?

Annotations already convey the read-only and non-destructive nature. The description adds minimal behavioral context beyond the scope ('all calendars'), but does not describe output format, pagination, or other side effects. Without annotations, this would be insufficient, but with annotations it is adequate.

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

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

The description is a single, direct sentence that front-loads the core function. Every word contributes meaning, with no redundancy or filler.

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

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

For a simple list tool with one optional parameter and no output schema, 'List all calendars for the account' is a complete and self-sufficient description. It accurately sets expectations for what the tool returns without needing extra detail.

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

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

The input schema fully documents the single optional parameter 'account' with a helpful description. The tool description adds no further parameter detail, but schema coverage is 100%, so the baseline of 3 applies.

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

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

The description clearly identifies the action (list) and the resource (calendars), with a scope ('for the account'). It is unambiguous and naturally distinguishes itself from sibling tools like list_events by naming 'calendars' as the target.

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 conveys its purpose but does not explicitly state when to prefer it over alternatives or what prerequisites exist. It is implied that one would use this to enumerate calendars for an account, but no direct comparison or exclusion is provided.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds the time-range scoping but does not disclose additional behaviors like pagination, default calendar, or that it accepts search queries (q). Since annotations cover safety profile, this is acceptable but not rich.

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 sentence with no filler or redundant information. It is front-loaded and immediately conveys the core function.

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 6 parameters fully described in the schema and annotations indicating a safe read operation, the description is adequate for an agent to understand the tool's core purpose. It does not explain return values, but no output schema exists; however, the schema and annotations compensate for most gaps. A slightly more detailed description with alternative tool references would push this to 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 coverage is 100%, with each parameter having a clear description. The description adds no extra meaning beyond the schema; it simply restates the time-range requirement. Baseline for high schema coverage is 3, which 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?

The description 'List calendar events within a time range' clearly specifies the verb (List), the resource (calendar events), and the scope (within a time range). It distinguishes from sibling tools like gws.cal.get_event (single event), gws.cal.create_event (create), and gws.cal.list_calendars (different resource).

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 is provided on when to use this tool versus alternatives. There is no mention of using gws.cal.get_event for a single event or how this differs from listing calendars. The only implied usage is that it lists events over a time range, but no exclusions or alternative references are 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?

Annotations already indicate a non-read-only, non-idempotent, non-destructive mutation. The description adds valuable behavior beyond annotations: patch semantics (only provided fields change), default calendar unless calendarId given, and the return of updated event details. This enriches the agent's understanding of the tool's effect.

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

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

The description is compact and front-loaded with the primary purpose. Each sentence adds distinct value: patch semantics, time format, calendar default, return info, and a user-preview reminder. There is no redundant or filler 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?

With 8 parameters and no output schema, the description compensates by mentioning return values (title, times, ID, link) and default behavior. It also clarifies patch semantics and timezone requirements. It lacks explicit error handling or permission notes, but given the richness of schema and annotations, it is sufficiently complete for an agent to use the tool effectively.

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

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

Schema coverage is 100%, so a baseline of 3 applies. The description adds meaning beyond the schema by clarifying patch semantics (only provided fields change) and specifying that start/end must include the timezone offset in RFC3339 format, which is not fully stated in the schema descriptions.

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

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

The description clearly states "Update (reschedule/edit) an existing calendar event" with specific verb and resource. It explains patch semantics, which distinguishes it from create_event and delete_event siblings, making its purpose unambiguous.

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

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

The description implies usage for modifying existing events and gives context like default calendar behavior and the instruction to "Preview the changes with the user before calling." It does not explicitly state when not to use it (e.g., for creation), but the purpose is clear enough to differentiate from siblings.

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

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

No contradiction—the description's read-only note aligns with the readOnlyHint annotation. It adds useful context like the matching semantics, but doesn't fully capitalize on adding unique value: it could mention pagination or result limits, though this is somewhat covered by the straightforward nature of the tool. Scores a solid 3.

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, clear topic sentences, information-dense without fluff. Everything 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 the context (2 simple params, no nested objects), the description covers the use case, behavior, and limitations. The only minor gap is distinguishing from sibling 'gws.contacts.search', but that doesn't lower the score significantly given the clarity of the directory search context.

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

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

Schema coverage is 100%, and description reiterates the matching semantics but adds no new details about formats or behaviors beyond what's in the schema. Meets the baseline for adequate param support.

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?

Specifies the action ('Search'), the resource ('Google Workspace organization directory'), and the matching criteria ('by name or email'), and clarifies what's returned ('display name and email addresses'). Clearly differentiates from personal Gmail contacts.

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 this is for Google Workspace organization directories and NOT for personal Gmail accounts, giving a clear exclusion criterion and expected behavior when used incorrectly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reaffirms 'Read-only — it never modifies contacts.' It adds return fields and searchable attributes (name, nickname, email, phone) beyond annotations, providing useful behavioral context without contradicting them.

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 3 sentences, front-loaded with purpose, then use case, then return info. No redundant phrases; 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?

For a simple 3-parameter search tool with no output schema, the description covers return fields, search criteria, and scope. It is sufficient for an agent to invoke correctly without additional clarification.

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

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

The schema covers all parameters (query, account, maxResults) with descriptions, so the baseline is 3. The tool description adds 'nickname' as a searchable field and provides use-case context, slightly enriching parameter meaning beyond the schema.

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

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

The description clearly states the tool searches the account's own Google Contacts by name, nickname, email, or phone, and specifies it returns display name, emails, and phone numbers. This distinguishes it from the sibling directory_search tool, making the purpose unambiguous.

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

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

It provides explicit use cases: resolving a name to email (before drafting mail) and looking up phone numbers. It implies the scope is the user's own contacts rather than directory-wide, but does not explicitly mention when not to use it or reference directory_search as an alternative.

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

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

The description adds meaningful behavioral context beyond the annotations: it states the document is 'empty' (except optional initial_text), 'owned by the account', and 'never modifies existing content'. The annotations already indicate non-destructive and non-read-only, but the description clarifies ownership and side effects. No contradiction with annotations.

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

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

The description contains redundancy: the second sentence ('Creates a new, empty document...') repeats information already stated in the first sentence about creating and returning ID and URL. This could be tightened into a single sentence, though the overall length is not excessive.

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 creation tool with no output schema, the description covers the key aspects: what it creates, the optional initial text, the return value (ID and URL), and the safety guarantee (never modifies existing content). It is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

The schema description coverage is 100%, so all three parameters are already well-described in the schema. The description adds minor value by explicitly mentioning initial_text is inserted at the start of the body, but this is largely redundant with the schema definition. No significant new meaning is added.

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

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

The description clearly states the tool creates a new Google Doc, which is a specific verb+resource. It distinguishes itself from sibling tools like gws.docs.insert_text and gws.docs.replace_text by emphasizing it never modifies existing content, making it the go-to tool for creating new documents.

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

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

The description implies usage for creating new documents and mentions it never modifies existing content, which helps differentiate from modification tools. However, it does not explicitly name alternatives or provide when-not-to-use guidance, so the guidance remains implicit rather than 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?

The description adds valuable context beyond annotations by warning that the tool 'irreversibly modifies user content' and advising user confirmation. It also clarifies literal text insertion (no regex). While destructiveHint is false, this is not a direct contradiction but a caution about side effects.

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

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

The description is two sentences, front-loaded with the core action, and every sentence adds value. No fluff or repetition of schema content.

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

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

The tool is simple and the schema plus annotations cover most details. The description provides essential behavioral context (irreversibility, user confirmation, literal insertion) that completes the picture. No return value is described, but output schema is absent and likely not critical for an insert 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?

With 100% schema description coverage, the schema already documents each parameter. The description adds meaning by explaining the 'location' values ('end' or 1-based index) and the literal nature of 'text' (no regex), which goes beyond the schema's simple descriptions.

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

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

The description states a specific action ('Insert literal text into a Google Doc') with a clear scope ('literal', 'No regex'). It distinguishes itself from sibling tools like gws.docs.replace_text by emphasizing literal insertion vs. regex-based replacement.

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

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

It explains the location parameter ('end' or index) and warns against regex use, implying when to use this tool over replace_text. It also provides a safety guideline ('Confirm intent with the user') for documents not created in the session, but does not explicitly name alternative tools.

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

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

Annotations already mark the operation read-only and non-destructive, but the description adds substantial behavioral detail: the wrapped <untrusted-document-content> tags, the explicit warning about ignoring instructions inside user data, and the round-trip compatibility with insert_text/replace_text. This goes beyond annotations.

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

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

Four sentences, each serving a distinct purpose: main function, secondary return, round-trip context, and security warning. No redundancy.

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

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

For a read-only tool with full schema coverage and no output schema, the description covers return formats (plain text, structured tree), the security-wrapping behavior, and round-trip compatibility. Enough for an agent to invoke 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 100% for document_id and account. The tool description does not add parameter-specific semantics beyond the schema, so baseline of 3 applies.

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

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

The description clearly states the tool reads a Google Doc as plain text and mentions the structured Docs tree inclusion. It distinguishes from sibling write tools like insert_text/replace_text by focusing on read behavior, and from drive.read_file by specifying Google Docs.

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

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

The description implies when to use the tool (when plain text of a Google Doc is needed) but does not explicitly mention alternatives or exclusions relative to siblings like drive.read_file or docs.create. No direct 'use when' guidance.

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

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

Beyond the annotations (destructiveHint=true, readOnlyHint=false), the description discloses that the tool 'irreversibly modifies user content', returns the number of occurrences changed, and clarifies literal substring matching behavior. These details add meaningful context about side effects and output that annotations do not provide. No contradiction with annotations.

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

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

The description is concise and front-loaded, opening with the core operation. Every sentence earns its place: the regex caveat, match_case default, return value, irreversibility, and confirmation warning. No redundant filler or verbose explanations.

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 5 parameters (3 required), destructive annotations, and no output schema, the description adequately covers return value, safety, and key behavioral constraints. It addresses the irreversible nature and the importance of user confirmation, making it sufficient for an AI agent to use safely and correctly.

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

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

The input schema already covers 100% of parameters with clear descriptions, including 'literal substring', 'default true' for match_case, and 'may be empty to delete matches'. The description repeats some of this information but does not add new parameter-level semantics beyond what the schema already states. Baseline of 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?

The description clearly states it 'Replace all occurrences of a literal substring in a Google Doc', giving a specific verb, resource, and scope. It also distinguishes from regex and implies a difference from insertion tools like gws.docs.insert_text, making it highly specific and unambiguous.

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

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

The description provides clear context for when to use the tool (replacing literal substrings) and includes an explicit exclusion: 'NOT regex'. It also adds a usage caution about confirming intent on documents not created in the session. However, it does not name alternative tools or explicitly say when not to use it beyond the regex caveat, so it stops short of a full 5.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. Description adds meaningful behavioral details: non-recursive, returns specific fields, and root default. This exceeds the bare annotation coverage without contradicting it.

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, front-loaded with the primary action, then return details and a usage tip. Efficient and well-structured with no redundant 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 simple list tool, the description plus schema and annotations provide a complete picture: what it does, what it returns, how to access root, and safety profile. No output schema is needed because the return fields are explicitly described.

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

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

Schema coverage is 100%, so baseline is 3. The description adds slight value by explaining the root-default behavior of folderId, but this is already present in the schema ('default: root'). No significant extra meaning beyond 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?

Description clearly states the action (list) and the target resource (files/subfolders in a Drive folder), with specific scope (non-recursive). It distinguishes itself from sibling tools like gws.drive.search and gws.drive.read_file by the semantics of direct listing.

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

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

Provides clear context on how to use the tool (omit folderId for root) but does not explicitly discuss when not to use it or recommend alternatives. The nature of the tool makes the intended use obvious, but explicit exclusions would strengthen it.

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

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

Beyond the readOnlyHint and destructiveHint annotations, the description adds substantial behavioral context: it explains the export formats, the 5MB limit, the return of metadata, and crucially the <untrusted-document-content> wrapper with a prompt-injection warning. This goes above and beyond what annotations provide.

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

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

The description is concise yet information-dense. Each sentence adds value: purpose, export behavior, return fields, and security warning. It is well-structured and front-loaded with the primary purpose.

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

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

Given the tool's complexity (multiple file formats, size limits, metadata-only returns, security concerns), the description covers all essential aspects. Without an output schema, it adequately explains the return values (file name, MIME type, size, content). The description is complete for an agent to use the tool correctly.

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

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

The input schema already covers both parameters (fileId and account) with descriptions, and the schema coverage is 100%. The description does not add extra meaning to the parameters, so the baseline 3 applies.

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

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

The description clearly states 'Read a Google Drive file's content and metadata' with a specific verb and resource. It distinguishes itself from siblings by detailing how Google Docs, Sheets, and Slides are exported (plain text, CSV, text) and the 5MB limit for other file types, which clarifies its broad scope relative to tools like gws.docs.read or gws.sheets.read_range.

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

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

The description gives clear context on what the tool does and its limitations (e.g., 5MB limit, binary files return metadata only), which helps an agent decide when to use it. However, it does not explicitly name alternative tools or state when to prefer them, so it stops short of a 5.

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

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

Annotations (readOnlyHint=true, destructiveHint=false) already establish the read-only safety profile. The description adds useful behavioral context beyond annotations: it specifies the return fields (file ID, name, MIME type, modified time, size, owners, web link) and notes the use of Drive query syntax, which is not covered by annotations. This adds meaningful information about what the operation does and returns.

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

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

The description is two sentences and front-loaded with the core purpose in the first sentence. The second sentence efficiently lists return fields and next steps. Every sentence earns its place with 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 search tool with a query syntax and an output schema absent, the description covers the key aspects: scope, syntax, return fields, and downstream usage. The schema covers parameter details like maxResults and account. Missing details such as pagination or error behavior are not critical for a read-only search tool and are partially addressed by annotations.

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%, with each parameter (query, account, maxResults) fully documented in the schema. The description does not add new meaning beyond the schema—it references 'Drive query syntax' but examples are already in the schema. Since the schema carries the full parameter documentation, the baseline score of 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?

The description clearly states the tool searches for files across the account's Google Drive using Drive query syntax. This specific verb-resource-scope combination differentiates it from siblings like gws.drive.list_folder (which lists folder contents) and gws.drive.read_file (which reads a specific file).

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

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

The description provides clear context on when to use this tool (searching across the entire Drive) and gives explicit follow-up guidance on using the returned file ID with drive.read_file or drive.list_folder. However, it does not explicitly contrast it with list_folder or state when not to use it, so the exclusion criteria are implied rather than stated.

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

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

Annotations already indicate a non-read-only, non-destructive, non-idempotent operation. The description adds that plain text and HTML bodies are supported, but does not disclose auto-detection behavior, draft persistence, or return value details. This is adequate given the annotations, but not particularly rich.

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

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

A single sentence that leads with the action and includes only essential supporting detail about body formats. No wasted words; very efficient.

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

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

With 8 parameters and no output schema, the description provides basic purpose but omits context on return values, default account behavior, and contentType auto-detection. It is sufficient for a straightforward invocation but leaves some ambiguity for a complex tool.

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

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

Schema coverage is 100% with well-described parameters. The description's mention of plain text and HTML bodies maps directly to the contentType and body parameters, adding minimal value 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 uses a specific verb and resource: 'Create an email draft.' It clearly distinguishes from sibling tools like send_draft and modify_message by focusing on the creation of a draft rather than sending or modifying.

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

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

The description implies usage for composing emails, but it does not explicitly state when to use this tool over alternatives such as send_draft or read_message. No exclusions or alternative recommendations are provided.

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

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

Annotations already indicate a non-read-only, non-destructive operation. The description adds behavioral context beyond annotations: it discloses the return value (new label ID) and the nesting behavior, which helps the agent anticipate outcomes. It does not cover rate limits or auth requirements but provides meaningful addition.

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

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

Two sentences with no wasted words: the first states the core action, the second gives key usage detail and return value. Fully front-loaded and efficient.

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

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

For a simple create tool with 4 parameters and no output schema, the description covers the essential points: what it creates, how to structure the name, what it returns, and how to use the result. The color and account parameters are self-explanatory from the schema, so no additional context is needed.

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 baseline is 3. The description adds value by explicitly explaining the '/' nesting syntax for the 'name' parameter, which is not fully detailed in the schema. Other parameters are adequately described in the schema, so the description enhances the key parameter without redundancy.

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 'Create a new Gmail label' with a specific verb and resource. It also distinguishes from siblings like list_labels and modify_message by explaining the returned ID's purpose and the nesting syntax.

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

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

Provides explicit guidance on nesting with '/', and explains the workflow: the returned ID is passed to mail.modify_message. This gives clear context on when and how to use the tool, effectively differentiating it from related operations.

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?

Goes well beyond the structured annotations (readOnlyHint:false, etc.) by disclosing the side-effect boundary ('does NOT send'), the return value (draft ID), and the critical attachment gotcha (filenames listed but bytes not re-attached, with a remediation pointer to gws.mail.get_attachment). The only minor gap is that draft persistence in the user's drafts folder is implied rather than explicitly stated, though 'Build a forward DRAFT' plus openWorldHint:true largely covers this.

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

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

Four sentences, zero fluff, with the single most important info (what it does and doesn't do) front-loaded first. Every sentence earns its place: purpose, behavior, return value + next step, and the attachment caveat with remediation. Dense with high-value behavioral detail while remaining perfectly scannable.

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

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

For a 6-parameter tool with no output schema and no nested objects, the description covers the essential gaps: it discloses the return value (critical since no output schema exists), the attachment behavior with a remediation path, and the prompt/comment semantics. The only area that could push this to a 5 would be explicit error-case handling (e.g., what happens with invalid message IDs or already-deleted messages), but those are edge cases here.

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

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

With 100% schema description coverage, the schema already documents all six parameters, establishing a baseline of 3. The description adds value on top by explaining how the 'comment' param surfaces (as a note prepended above the forwarded content) and contextualizing the 'standard forwarded-message block' structure that shapes how 'to', 'cc', and 'bcc' params will be used in output. This is a meaningful semantic bridge between the schema fields and the runtime behavior.

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?

Uses a specific verb-plus-resource construction ('Build a forward DRAFT of an existing message') with a critical scope qualifier ('does NOT send') that disambiguates it from the sibling tools gws.mail.create_draft and gws.mail.send_draft. The emphasis on 'DRAFT' in caps and the parenthetical warning leave zero ambiguity about what this tool does and, more importantly, doesn't do.

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

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

Provides a clear workflow pointer ('send it with mail.send_draft') that tells the agent the natural next step after obtaining the draft ID. The description makes its use case (forwarding existing messages into a draft) clear, though it doesn't explicitly contrast itself against gws.mail.create_draft or state when NOT to use it—those exclusions are implied 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?

The description discloses key behavioral traits beyond annotations: it returns base64-encoded bytes in the JSON payload (data_base64), includes filename, MIME type, and size, and wraps content in <untrusted-document-content> tags with a security warning about not following directives inside. This is critical behavioral context that annotations (readOnlyHint, openWorldHint) do not provide. The description adds significant value here.

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

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

The description is concise and front-loaded: it states the primary action in the first sentence, then provides necessary context about how to obtain the attachmentId, the return format, and a security warning. Every sentence earns its place, and the structure is logical. No wasted words.

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

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

Given the tool's complexity (3 params, no output schema, no nested objects), the description is complete. It explains the return payload structure (filename, MIME type, size, data_base64), the security wrapper, and the source of attachmentId. The annotations cover read-only and non-destructive aspects, and the description covers the rest. No gaps identified.

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 all three parameters. The description adds value by explaining the relationship between attachmentId and the read_message/read_thread tools, and clarifies the return format (data_base64). However, it doesn't add much beyond the schema for the 'account' parameter, which is already described. Baseline 3 plus the added context about attachmentId provenance and return format justifies a 4.

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

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

The description clearly states the tool fetches a single attachment's bytes from a message, specifying the verb (fetch), resource (attachment), and scope (single attachment from a message). It also distinguishes itself from siblings by noting the attachmentId comes from mail.read_message / mail.read_thread, which is a clear differentiator.

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

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

The description explicitly states when to use this tool: after obtaining attachmentId from mail.read_message or mail.read_thread. It also provides a clear exclusion: it fetches a single attachment, not multiple, and implies alternatives for listing messages. This is explicit usage guidance with a clear 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?

Annotations already state readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds the specific return fields (email, messages total, threads total), which is useful behavioral context beyond annotations. It doesn't overexplain, but this is sufficient for a simple read operation.

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

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

The description is a single sentence, front-loaded with the action and resource, and contains zero filler. Every word contributes to understanding what the tool does.

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?

This is a minimal tool with one optional parameter, clear annotations, and a description that lists the exact output fields. No output schema is needed, and the description fully covers what the agent needs to know for selection and invocation.

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

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

Schema description coverage is 100% because the only parameter 'account' is fully described ('Account label or email. Uses default if omitted.'). The description adds no additional parameter meaning, 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?

The description uses a specific verb ('Get') and clearly identifies the resource ('Gmail profile info') and the exact data returned (email, messages total, threads total). This fully distinguishes it from sibling mail tools like list_labels or read_message.

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 clearly implies its usage as a read-only retrieval of account-level profile data, which is distinct from message-level or label-level operations. No explicit alternatives or exclusions are mentioned, but the context is sufficiently clear for an agent to choose this tool for profile information.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds no extra behavioral context beyond what is obvious from the name and schema, such as return format or system-label inclusion.

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, efficiently worded sentence that states the tool's purpose without redundancy or unnecessary detail.

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, read-only list operation with a single optional parameter, a one-sentence description is sufficient. The annotations and schema cover safety and parameter semantics, so no further context is needed.

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% with the 'account' parameter documented as 'Account label or email. Uses default if omitted.' The description references 'for the account' but adds no additional meaning beyond the schema.

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

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

The description uses a specific verb 'List' with the resource 'Gmail labels' and scope 'for the account', clearly distinguishing it from sibling tools like gws.mail.create_label or gws.mail.read_message.

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

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

The description implies usage by stating its function, but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or alternative tools.

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

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

Annotations indicate readOnlyHint=false and destructiveHint=false. The description adds semantic context by mapping label changes to actions like archiving and read/unread status. It does not disclose error scenarios or authorization requirements, but annotations already cover the safety profile, so score 4.

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?

Single sentence of 19 words, front-loads the core action, includes useful examples, and uses no filler. Highly concise.

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

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

For a simple mutation tool with well-documented schema and no output schema, the description covers common workflows (archiving, starring, read/unread, custom labels). It gives enough context for an agent to select and invoke 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?

Input schema provides 100% coverage for all 4 parameters, each with clear descriptions. The description does not add further parameter-level detail beyond the schema examples, so 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?

Description clearly states 'Add or remove labels from a Gmail message' with a specific verb and resource. It distinguishes from sibling tools like gws.mail.read_message and gws.mail.create_draft by focusing on label modification. Examples of archiving, starring, and marking read/unread clarify the scope.

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

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

Provides explicit use cases: 'use for archiving, starring, marking read/unread, or applying custom labels'. This tells when to invoke the tool. Does not specify alternatives or exclusions, but the use cases are clear, earning a 4.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds no additional behavioral context beyond what annotations provide, such as return format nuances or side effects. With annotations covering the safety profile, a score of 3 is appropriate.

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 that wastes no words. It directly states the tool's purpose without extraneous information.

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

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

Given there is no output schema, the description could better explain what 'full content' includes (e.g., headers, attachments, body). The format parameter gives some hint, but the description does not elaborate on return values or error behavior, leaving moderate gaps for a simple 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?

The input schema has 100% coverage with clear descriptions for all three parameters, including format options and the default account behavior. The description itself adds no parameter information, but the schema carries the full burden, so the baseline of 3 applies.

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

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

The description clearly states the action ('Read') and the resource ('the full content of an email message'), which distinguishes it from sibling tools like read_thread (which reads a thread) and search (which finds messages). It is specific and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or cases where a different tool (e.g., read_thread or search) would be more appropriate.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the scope ('all messages') but doesn't mention return format, ordering, or potential large response sizes. With annotations providing the core behavioral context, this modest addition is adequate.

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

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

The description is a single concise sentence with no filler or repetition. It fully communicates the tool's purpose without exceeding necessity.

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 read operation, the description covers the essential purpose. There is no output schema, but the description implies a collection of messages. Combined with the schema's format parameter, the context is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, with each parameter (format, account, threadId) already well-documented. The tool description doesn't add additional parameter semantics, so the baseline 3 applies.

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

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

The description is specific and unambiguous: 'Read all messages in an email thread' clearly identifies the verb (read), resource (email thread), and scope (all messages). This distinguishes it from sibling tools like gws.mail.read_message (single message) and gws.mail.search.

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 clearly conveys when to use this tool: when the entire thread content is needed. While it doesn't explicitly name alternatives or exclusions, the 'all messages' wording provides clear context that differentiates it from single-message reads.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds value by explaining the Gmail search syntax, but it does not disclose behaviors such as pagination, result format, or whether results include full content or just metadata.

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

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

The description is a single sentence that conveys the essential purpose and includes a relevant example. It is concise, front-loaded, and contains no superfluous content.

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

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

For a simple search tool with strong annotations and full schema coverage, the description is mostly complete. The only notable gap is the lack of explicit return-value description, but given the clarity of 'Search emails' and the example, it remains adequate.

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

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

All three parameters are fully described in the schema, so the baseline is 3. The description adds a small amount of context with the example query, but does not substantially beyond what the schema already provides for account or maxResults.

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

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

The description uses a specific verb and resource ('Search emails') and further specifies the query syntax with a concrete example. This clearly distinguishes it from sibling tools like read_message and list_labels, making the purpose unambiguous.

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

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

The description implies usage by indicating a search function with Gmail syntax, but it does not explicitly state when to prefer this over alternatives or mention any exclusions. For example, it could clarify that read_message is for retrieving specific messages, but the context is sufficient for basic selection.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, covering the mutation and external side-effect profile. The description adds the 'after create_draft' sequencing but does not describe what happens to the draft after sending or other behavioral details.

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 sentence that front-loads the purpose and gives a usage hint. Every word earns its place with no redundancy.

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

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

For a simple send action with two parameters and no output schema, the description is adequate. It covers the key prerequisite (create_draft) and the annotation provides the safety context. It could mention irreversibility or external sending, but openWorldHint already signals that.

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%, with both account and draftId described in the schema. The description reinforces that draftId comes from create_draft but does not add new meaning beyond the schema's own descriptions.

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

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

The description clearly states the action: 'Send an existing email draft' with a specific verb and resource. It also distinguishes itself from the sibling create_draft by noting 'Use after create_draft', making the tool's role 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 'Use after create_draft' provides explicit sequencing, telling the agent when to use this tool. However, it does not explicitly state when not to use it or name alternative tools, though no direct alternative exists in the sibling list.

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

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

Annotations already indicate non-read-only (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds valuable behavioral context beyond this: it explains the INSERT_ROWS option, additive nature (never overwrites), default value_input_option behavior (parsing formulas/dates), and the ability to switch to RAW. This clarifies the tool's side effects without contradiction. It could go higher if it mentioned idempotency, but the existing context is strong.

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 paragraph but well-structured: starts with the core action, then explains key parameters and behavioral details, and ends with the return value. Every sentence adds value without redundancy. It is concise yet comprehensive, covering all critical aspects without verbosity.

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 write operation with no output schema, the description is quite complete: it covers the core functionality, parameter behavior, safety profile, and return value. It lacks explicit discussion of error conditions (e.g., invalid range) or permission requirements, but given the annotations and simple schema, it is generally adequate. The main gap is not describing the exact structure of the returned range, but the description mentions it, which is sufficient.

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

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

Schema coverage is 100%, so the schema already documents all five parameters. The description adds some meaning beyond the schema: it迫害 it clarifies the 'range' parameter as the table to append after, and explains the 'values' format and the effect of 'value_input_option'. However, these clarifications are not extensive; for example, it could detail the format of the returned range or clarify 'account' usage, but the baseline 3 is appropriate given the high schema coverage.

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

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

The description clearly states the tool appends rows to a Google Spreadsheet, specifying the key operation ('Append rows') and the resource (Google Spreadsheet). It distinguishes itself from sibling tools like gws.sheets.write_range by emphasizing that it appends after a table without computing the next empty row, and explicitly says it never overwrites, which differentiates it from write_range and clear.

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

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

The description provides clear context on when to use this tool: when you need to append rows without overwriting, and it explicitly mentions the INSERT_ROWS option and preservation of existing data. However, it does not explicitly state when NOT to use it (e.g., use write_range for overwriting) or name alternative sibling tools, so it misses the full exclusion guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, and the description is consistent—no contradiction. It adds meaningful context: only values are removed while properties are preserved, and the cleared range is returned. This goes beyond what the structured annotations convey.

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

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

Four tight sentences, each earning its place: core action, range-syntax clarification, precise behavioral scope, and a safety warning. No fluff, no restating of schema fields, front-loaded with the most important 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 mutating tool with rich annotations and a small parameter set, the description covers the essentials: exact behavior, preservation semantics, return value, and a safety note. The explicit return-value statement compensates for the absence of an output schema.

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

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

Schema coverage is 100%, so per rubric the baseline is 3. The description clarifies that a bare sheet name like 'Sheet1' is valid range syntax and reinforces the A1 notation also present in the schema. It adds marginal convenience but doesn't substantially expand on parameter semantics.

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

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

The description opens with a clear verb+resource statement: 'Clear (empty) the values in a range of a Google Spreadsheet.' It further scopes the operation by stating only values are removed while formatting/data validation remain intact and no rows/columns are deleted. However, it doesn't explicitly reference sibling tools like gws.sheets.write_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?

The instruction to 'Confirm intent with the user before calling it on documents you did not create in this session' provides explicit when-to-call and when-to-confirm guidance. This implies an exclusion context (avoid autonomous calls on user-owned sheets), though no sibling alternatives are named.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds valuable behavioral detail: optional seeded tab, return of ID and URL, ownership by account, and the guarantee of not modifying existing content. This goes beyond the structured metadata without contradicting it.

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

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

The description is somewhat redundant: 'Create a new Google Spreadsheet' and 'Creates a new, empty document owned by the account' repeat similar information, as do the two mentions of returning ID/URL. While front-loaded with the primary action, the repetition means not 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?

For a create tool with no output schema, the description adequately covers inputs, behavior (seeding, non-modification), and return values (ID and URL). It does not mention required scopes or permission topics, but annotations hint at open-world behavior. Overall fairly complete for its complexity.

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

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

Schema has 100% coverage for all three parameters. The description enhances initial_values by explaining its array-of-arrays shape and that it seeds starting at A1, which the schema description only calls 'cell grid'. This adds meaningful format context 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 clearly states the verb 'Create' and specific resource 'new Google Spreadsheet'. It distinguishes from siblings by specifying it never modifies existing content, differentiating it from write_range, and the 'Spreadsheet' scope differentiates it from docs.create.

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 'It never modifies existing content' provides clear context for when not to use this tool (i.e., when modifying existing sheets). It also references write_range for the shape of initial_values, hinting at an alternative. However, it does not explicitly name alternatives or state 'use write_range for modifications'.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a valuable behavioral detail: that returned content is wrapped in <untrusted-document-content> tags and should not be treated as instructions. This goes beyond annotations and helps prevent prompt injection issues.

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

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

The description is two sentences long, front-loaded with the core purpose, and the security note is a meaningful addition. No redundant or vague wording is present; 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?

For a simple read-only list tool with comprehensive schema coverage and annotations, the description is complete. It states the return fields (title, sheet ID, grid dimensions) and includes a critical security warning. No output schema exists, so the description adequately covers what the agent needs to know.

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 does not add extra meaning to the parameters beyond what the schema already provides. It does mention 'spreadsheet' but not the 'account' parameter, so the schema remains the primary source of parameter semantics.

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

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

The description clearly states the specific action: 'List the tabs (sheets) in a Google Spreadsheet with title, sheet ID, and grid dimensions.' This uses a specific verb ('List'), specifies the resource (tabs in a spreadsheet), and distinguishes it from sibling tools like read_range or write_range.

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

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

The description implies usage by stating what the tool does but does not explicitly explain when to choose this over alternatives or mention any exclusions. Given the sibling context, the purpose is clear enough for an agent to infer, but no explicit guidance is provided.

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

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

The description goes well beyond the readOnlyHint annotation by detailing the response structure (human-readable preview plus JSON payload), truncation behavior via 'truncated' and 'total_rows_in_range', and the use of <untrusted-document-content> tags with a security warning against prompt injection. This is rich behavioral context.

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

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

The description is concise and well-structured, with each sentence serving a distinct purpose: purpose, parameter clarification, response format, truncation handling, and security warning. No wasted words, and the most critical information is front-loaded.

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

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

Despite having no output schema, the description fully explains the return format and edge cases (truncation, untrusted content). All four parameters are documented in the schema, and the description adds the necessary context for effective use. It is complete for the tool's complexity.

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

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

While the schema covers all parameters (100%), the description adds meaningful context for the 'range' parameter by explaining A1 notation and providing examples. It also implicitly links max_rows to truncation behavior, adding value beyond the schema's bare descriptions.

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

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

The description clearly states the tool reads a single range from a Google Spreadsheet, with a specific verb ('Read') and resource ('range'), and distinguishes it from siblings like write_range and list_tabs. It also gives concrete A1 notation examples.

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

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

The description implies usage for reading a range but does not explicitly state when to use this versus alternatives, nor does it mention any exclusions or prerequisites. It relies on the tool name and basic context rather than providing explicit guidance.

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

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

Beyond annotations declaring destructiveHint, the description adds essential context: 'This tool irreversibly modifies user content' and instructs to confirm intent with the user, especially for documents not created in the session. It also explains the behavioral difference between USER_ENTERED and RAW input options.

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

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

The description is concise and front-loaded with the primary purpose, followed by necessary parameter details and a safety warning. Each sentence contributes meaningful information without unnecessary verbosity.

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

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

For a destructive write tool with no output schema, the description is complete: it covers the core action, parameter semantics for the more complex fields, and includes a clear warning about irreversibility and user confirmation. It equips an agent to use the tool safely and correctly.

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

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

Schema coverage is 100%, providing baseline meaning for all parameters. The description adds extra value by detailing the structure of 'values' with an explicit example and clarifying that value_input_option defaults to 'USER_ENTERED'—information not fully present in the schema description.

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

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

The description clearly states the action with a specific verb and resource: 'Write values to a range in a Google Spreadsheet.' It distinguishes from the sibling read tool by the verb 'write' versus 'read,' and the example further clarifies the intended use.

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

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

The description provides clear context that this is for writing values, but it does not explicitly name alternatives like gws.sheets.read_range or specify when-not-to-use. However, it does include a caution to confirm intent with the user, which offers some usage guidance.

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

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

Beyond the destructiveHint=true annotation, the description states the tool 'irreversibly modifies user content' and instructs to confirm intent, adding practical safety context. It also clarifies that requests are 'raw' and 'exactly as documented' the API, setting expectations for low-level 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?

Four concise sentences: purpose, parameter explanation, role statement, and safety warning. No redundancy, each sentence is directly useful.

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

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

For a destructive, low-level mutation tool, the description covers what it does, how to construct the main input, and critical safety instructions. Combined with existing annotations and schema, the agent has sufficient context to use 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?

For 'requests', the description explains it's a JSON array of Slides API Request objects with examples, adding significant meaning beyond the schema. 'existing presentation' in the first sentence clarifies that presentation_id must reference an existing file. The 'account' parameter is not covered in the description, but schema covers it.

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

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

The description uses a specific verb ('Apply') and resource ('batch of raw Slides API requests to an existing presentation'), clearly distinguishing it from siblings like create or get. It also identifies itself as 'the general-purpose editing primitive,' which is a clear scope statement.

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

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

It explicitly calls out that the caller constructs request objects, which implies it's for advanced/batch operations, and adds a warning to confirm before use on documents not created this session. It could name specific alternative tools (e.g., gws.slides.create) but the 'general-purpose editing primitive' phrase gives context for when to use it.

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

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

Beyond the annotations, the description adds useful behavior: it creates a new empty document, is owned by the account, returns a shareable URL, and never modifies existing content. This aligns with readOnlyHint=false and idempotentHint=false without merely repeating structured metadata.

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

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

The description is front-loaded and mostly concise, but it redundantly states the creation and return of ID/URL in both the first sentence and the later sentence. It could be tightened to three sentences without losing substance.

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 creation tool with no output schema, the description covers the essential inputs, output expectations, ownership, emptiness of the new doc, and recommended follow-up tool. Minor redundancy and lack of explicit edge cases keep 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 coverage is 100%; title and account are already described in the schema. The description reinforces 'title' and mentions the resulting ID/URL, but it does not add substantial new meaning about the parameters themselves.

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

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

Description opens with a specific verb and resource: 'Create a new Google Slides presentation with the given title.' It identifies the output (ID and URL) and distinguishes itself from slides.batch_update by explicitly pointing to that tool for adding content.

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

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

The description clearly states the tool's role and gives an explicit next step: 'Add slides and content with slides.batch_update.' It does not name exclusions or directly compare with gws.docs.create/sheets.create, but the context is clear enough.

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

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

Beyond the readOnlyHint=true annotation, this description adds exceptional value: it details the return payload composition (slide count, summaries, raw tree) and, critically, discloses the prompt-injection defense — content wrapped in <untrusted-document-content> is user data and must not be treated as instructions. This goes well beyond what the annotations communicate and is the kind of security-relevant behavioral context agents need.

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

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

Three sentences, each earning its place: the first states the purpose, the second adds payload detail, and the third delivers a critical security directive. The most important information is front-loaded. It stays just shy of a 5 because the security warning could arguably be folded more tightly, but overall it's tight and free of fluff.

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

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

For a simple read tool with one required parameter and solid annotations, the description is near-complete: it specifies the return shape, notes the inclusion of the raw structural tree, and provides the all-important security context given there is no output schema. It doesn't cover error cases (e.g., presentation not found), but that's beyond what's typically expected for a tool of this complexity.

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

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

Schema description coverage is 100% (both `account` and `presentation_id` documented inline in the schema), so the baseline of 3 applies. The description itself adds no parameter-specific detail, but it doesn't need to — the schema already explains the account fallback and presentation ID format. The description's content about return values is redundant with the description's primary purpose.

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

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

The description uses a specific verb-resource pair ('Read a Google Slides presentation') and details the exact output scope: slide count, per-slide plain-text summary covering text boxes/shapes/table cells, and the raw structural tree. It clearly differentiates from sibling tools like gws.slides.batch_update and gws.slides.create, which are write operations by name, by establishing 'get' as the read tool.

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

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

The usage is implied through the verb 'Read' and the readOnlyHint annotation, and the coverage of the return value implies when this tool is appropriate (any time presentation content is needed). However, there is no explicit mention of when NOT to use it or which sibling tools to use instead for write scenarios — no explicit alternatives are named.

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

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

The annotations already indicate a non-read-only, non-destructive operation, and the description adds valuable context beyond that: it explicitly mentions reversibility, that the task is not deleted, the default tasklist behavior, and the exact return fields. This gives the agent a fuller understanding of side effects.

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

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

The description is concise and efficiently structured in three sentences. Every sentence adds value: what happens, reversibility, default behavior, and expected return contents. No redundant or filler language is present.

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

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

For a simple three-parameter tool with no output schema, the description is complete enough. It covers the action, side effect/reversibility, defaults, and return shape, while annotations cover safety semantics, and sibling tools give context for alternatives.

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

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

The input schema covers all parameters with descriptions (100% coverage), so the description is not required to explain parameters in depth. It does add practical context for tasklist defaulting to '@default' and notes the account default only appears in the schema. No significant additional parameter semantics are provided.

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

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

The description clearly states the operation: 'Mark a task as completed (sets its status to ''completed'')'. It specifies the exact resource (task) and action, and distinguishes itself from deletion by emphasizing 'This is reversible — the task is not deleted.'

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 conveys that this tool is for completing tasks and not for deleting them, which indirectly distinguishes its use from deletes. However, it does not explicitly say when to choose this tool over alternatives such as gws.tasks.delete or how to revert the completion operation.

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

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

The description adds important behavioral details beyond the annotations: the RFC3339 timestamp's time portion is discarded, the tasklist defaults to '@default', and the tool returns the new task's title, due, and ID. The annotations already indicate a non-read-only, non-idempotent write tool, and the description enriches this with useful concrete behavior.

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

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

The description is three focused sentences, front-loaded with the core action and immediately followed by essential details about required parameters, defaults, and return values. There is no filler or repetition.

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

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

With no output schema, the description compensates by naming the return fields (title, due date, ID). It also clarifies a subtle Google Tasks behavior and the default task list context, making the tool self-sufficient for an agent to select and invoke correctly.

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

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

The input schema provides descriptions for all five parameters, so the baseline is 3. The description adds meaningful semantic context by clarifying the due date storage behavior and the tasklist default, giving the agent deeper understanding than the schema alone.

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

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

The description opens with a specific verb ('Create') and a clear resource ('a new task in a task list'), and it clearly distinguishes this tool from sibling task tools like gws.tasks.list, gws.tasks.complete, and gws.tasks.delete. It also names key behaviors and defaults that make the purpose unmistakable.

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

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

The description makes it obvious this tool is for creating tasks, and the sibling tool names provide clear alternatives for reading, completing, or deleting tasks. It does not explicitly say 'use this instead of X', but the context and defaulting behavior provide adequate usage guidance without confusion.

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

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

The description discloses irreversible destructive behavior ('cannot be undone', 'Permanently delete') and requires confirmation, adding context beyond the annotations (destructiveHint=true). It also mentions the return value (deleted task's ID and list), which is not present in any structured field.

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, front-loaded with the core action and critical detail (irreversibility). Every sentence provides value: purpose, user guidance, alternative, default, and return value. No fluff.

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

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

For a simple delete tool with three parameters and no output schema, the description is comprehensive. It covers behavior, caution, alternative tool, default parameter value, and return value, making it fully adequate for an agent to use 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 covers all parameters (100% coverage), but the description reinforces the tasklist default ('@default') and clarifies that tasklist defaults to the account's default list. This adds practical meaning beyond the schema's parameter descriptions.

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

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

The description clearly states the tool's purpose: 'Permanently delete a task from a task list.' It uses a specific verb and resource, and distinguishes itself from the sibling tool tasks.complete by explicitly contrasting deletion with marking done.

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

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

Provides explicit usage guidance: 'To mark a task done without removing it, use tasks.complete instead.' Also instructs to confirm with the user before calling due to irreversibility, and notes the default tasklist behavior.

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

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

Beyond the readOnlyHint annotation, the description adds value by disclosing that only active tasks are returned by default and how to include completed ones. It also explains the meaning of '@default' and the fields in each task, giving the agent a full picture of the operation's 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?

Three sentences, each serving a purpose: what the tool does, what it returns, and how to control the output. No fluff or unnecessary detail.

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 read-only list operation with only 3 optional parameters and no output schema, the description fully covers the behavior, defaults, and return contents. It leaves no ambiguity about how to use the tool or what to expect.

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

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

Schema coverage is 100% for parameters, and the description adds extra semantics beyond the schema by explaining that '@default' means the account's default list and that status has values 'needsAction/completed'. It clarifies behavioral defaults already in the schema but adds meaning to the values.

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 starts with 'List the tasks in a task list', using a specific verb and resource. It clearly distinguishes from sibling tools like create, complete, delete, and list_tasklists by focusing on reading tasks, and even lists return fields (title, status, due date, notes, ID).

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

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

Provides clear context on default behavior: tasklist defaults to '@default' and showCompleted defaults to false. While it doesn't explicitly mention alternatives like 'use list_tasklists for available lists', the intended use is implied well enough for a list operation, with no exclusions needed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the primary safety profile is covered. The description adds behavioral context by specifying the returned fields (title and ID) and the special default-list behavior ('@default'), which is valuable beyond the annotations.

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

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

The description is three dense sentences with no filler. The first states the core purpose, the second specifies output fields, and the third gives high-value integration instructions about reusing list IDs and the default fallback. 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?

Given the one optional parameter and no output schema, the description covers the necessary operations, return values, and how the results will be consumed by sibling tools. It even explains the 'tasklist' argument behavior across the tasks tool group, making the description self-sufficient for an agent.

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

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

There is only one optional parameter, 'account', and the schema already describes it fully as 'Account label or email. Uses default if omitted.' The description does not add further syntax or behavior details about the parameter, so it stays at baseline coverage.

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

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

The description opens with a specific action: 'List the account's Google Tasks task lists.' It clearly names the resource type and explicitly states the return shape (title and ID), making it obviously distinct from the sibling gws.tasks.list, which lists tasks themselves.

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 explains how to consume this tool's output: 'Use a returned list ID as the 'tasklist' argument to the other tasks tools; omit 'tasklist' there to target the account's default list.' It gives practical when-to-use guidance for downstream operation, but it does not explicitly contrast with gws.tasks.list or state exclusions.

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