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

Beyond the annotations (readOnlyHint=true, openWorldHint=true, destructiveHint=false), the description explicitly states that the tool never starts OAuth or reveals tokens. This provides important behavioral guarantees about side effects and privacy, enhancing transparency.

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

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

The description is concise and well-structured. It opens with the main action, then adds critical clarifications (no OAuth, no tokens) and a usage note. Every sentence adds value, and there is no 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 simple listing tool, the description is complete. It states what is returned (accounts and scopes), what is not done (OAuth, tokens), and how the result is intended to be used (selecting an accountId). No essential information is missing given the tool's simplicity and lack of 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?

The tool has zero parameters, and the schema is empty. According to the guidelines, 0 params yields a baseline of 4. The description does not need to explain parameters because there are none, and the empty schema is fully covered.

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

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

The description clearly states the tool's purpose: listing configured Google accounts and granted scopes. It also specifies what it does not do (never starts OAuth, never reveals tokens) and how the output is used (select an explicit accountId for subsequent actions). This 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 implies the tool should be used to list available accounts before selecting one for subsequent actions, which guides typical usage. However, it does not explicitly contrast with sibling tools or state conditions for when to use this tool over others. Still, the context is clear enough for a listing utility.

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 side effects (sendUpdates implies notifications) and approval nuances (recurring edits require approval). It goes beyond the basic readOnlyHint annotation by explaining the mutation impact and special cases, making the tool's behavior transparent.

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

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

The description is two sentences long and packs essential information without fluff. It is well-structured, starting with the core action and then adding usage constraints and approval conditions, ensuring high readability and 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?

The description provides sufficient context for a create operation: it defines the event type, required fields, and approval conditions. It does not mention return values or error handling, but since there is no output schema and the primary purpose is clear, the missing details are minor and do not hinder correct usage.

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

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

The schema has zero parameter descriptions and the tool description does not explain individual fields beyond a passing mention of 'timed', 'all-day', 'attendees', and 'recurrence'. The description does not compensate for the 0% schema coverage, leaving the agent to infer the meaning of accountId, calendarId, event, and requestId from context.

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

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

The description clearly states the action (create) and the resource (a default calendar event), distinguishing it from update/delete/list siblings. It specifies event subtypes (timed or all-day) and key attributes (attendees, recurrence), leaving no ambiguity about the tool's purpose.

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 highlights required parameters (requestId and explicit sendUpdates) and provides concrete conditions for approval bypass (private, guest-free, own primary calendar, sendUpdates:none). This gives the agent actionable guidance on when to use this tool and what constraints apply.

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 destructive behavior, but the description adds valuable context by requiring human approval and specifying If-Match usage. This goes beyond the basic annotation hints, providing operational expectations.

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

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

The description is concise (two sentences), front-loads the action and scope, and includes essential requirements without redundancy. Every sentence adds value.

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

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

The description covers the core operation, mandatory parameters, and the approval workflow. It doesn't mention return values or side effects beyond deletion, but for a destructive operation with human approval, these are secondary. The If-Match note adds important contextual 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 description names three of the six parameters (requestId, scope, sendUpdates) and clarifies their roles. The remaining parameters (accountId, calendarId, eventId) are self-explanatory from name and context, but schema descriptions are absent, so the tool description only partially compensates for the 0% schema coverage.

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

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

The description clearly states the action (delete), the specific resource types (event, occurrence, series), and the scope. It also mentions the human approval requirement, distinguishing it from other calendar operations. Sibling tools confirm the unique purpose.

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 lists mandatory parameters (requestId, recurrence scope, sendUpdates) and mentions the If-Match requirement. While it doesn't explicitly compare with sibling tools for when to use deletion vs. update, the action and constraints are clear enough for an agent to select it appropriately.

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 explicitly states a meaningful behavior: 'Returns no slots if any required calendar is unknown.' This goes beyond the readOnlyHint annotation to explain a failure mode. It does not contradict 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 a single concise sentence with no redundant words. It packs all essential information efficiently.

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?

While the core purpose and a failure mode are described, the description does not outline the structure of a successful response (e.g., list of time ranges with start/end). Since there is no output schema, this omission leaves some ambiguity about expected return data.

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

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

The description adds semantic meaning to several parameters: 'durationMinutes' is clarified by 'at least durationMinutes', 'timeMin/timeMax' are scoped to 'within a 31-day window', and 'calendars' is defined as 'explicit account/calendar pairs'. This enriches the schema which only provides field names and types.

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

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

The description clearly states the tool's action ('Find maximal common-free ranges'), the resource ('across explicit account/calendar pairs'), and key constraints ('at least durationMinutes', 'within a 31-day window'). This unambiguously differentiates it from other calendar tools.

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

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

The description implies a specific use case (finding overlapping availability across multiple calendars) without explicitly naming alternatives. The mention of 'explicit account/calendar pairs' and the 31-day window provides enough context for an agent to choose this over other calendar tools, though it could be more explicit about when not 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?

The description adds behavioral details beyond the readOnly/openWorld annotations: missing or failed sources are treated as unknown/free, and concurrency limits are specified. It does not describe output format, but the behavior for failures is valuable.

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, with no unnecessary words. It front-loads the core purpose and then adds key constraints and behavioral notes.

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 provides sufficient context for an agent to understand the tool's scope, limits, and edge case behavior. It does not include output format, but in the absence of an output schema, the purpose and failure semantics are enough for basic use.

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 3 parameters, but none have descriptions. The description clarifies that 'calendars' are explicit account/calendar pairs, and mentions a maximum window of 31 days, but does not explicitly define timeMin/timeMax as the window boundaries. This leaves some ambiguity.

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

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

The description clearly states the action (read free/busy) and the resource (explicit account/calendar pairs), and includes additional operational details like batching and concurrency limits. It is distinct from sibling tools like calendar_find_availability by focusing on explicit pairs.

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 some usage constraints (max 50 calendars per request, 4 concurrent requests, 31-day max window) but does not explicitly compare to alternative tools or state when to prefer this over others. It gives implicit guidance through the 'explicit pairs' phrasing.

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 readOnlyHint=true and destructiveHint=false, and the description's 'Read' aligns with these. No additional behavioral details are given, but the description is consistent and adds minor context about exactness.

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 unnecessary words. It is well-structured and directly communicates the tool's 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?

The tool has no output schema, and the description does not mention what the read operation returns (e.g., event details, occurrence metadata) or any potential errors. This leaves some ambiguity for an agent about the expected response.

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

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

The description partially explains the parameters: 'exact Google event or occurrence ID' maps to eventId, 'explicit account' to accountId, and 'calendar' to calendarId. However, it does not elaborate on formats, constraints, or relationships between parameters, and schema coverage is only 0%.

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 'read' and the specific resource ('exact Google event or occurrence ID') along with the context ('explicit account and calendar'). This distinguishes it from listing or updating tools.

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

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

The description implies this tool is for retrieving a single specific event by ID, but it does not explicitly state when to prefer it over alternatives like calendar_list_events or calendar_list_instances. No when-not 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 readOnly and destructive annotations already cover side effects, and the description adds transparency about pagination limits and query-bound continuation. It does not mention authentication or possible errors, but the behavior is consistent with 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 two concise sentences with no redundant or promotional language. It front-loads the core purpose and then gives a necessary pagination 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?

The description explains the scope and pagination but does not describe the returned calendar fields or any preconditions such as selecting the account via accounts_list. Since there is no output schema, a bit more detail about the response shape would improve completeness.

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

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

The description gives partial meaning to parameters: 'one explicitly selected account' maps to accountId, 'query-bound continuation' maps to cursor, and 'at most 100 per page' maps to pageSize. It does not fully compensate for the 0% schema coverage, but the parameter names are self-explanatory and supported by these hints.

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 ('Discover') and a clear resource ('calendars accessible to one explicitly selected account'), distinguishing it from event/instance listing tools. It also communicates the account-scoped nature of the operation.

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 indicates when to use the tool: to discover calendars for a selected account. It does not explicitly name alternatives or state when not to use it, but the account-scoped purpose provides strong contextual 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 readOnlyHint and openWorldHint annotations, the description discloses that expanded occurrences require explicit offset-bearing timeMin/timeMax and that singleEvents:false reads underlying masters and exceptions. These are non-obvious behaviors that improve transparency.

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

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

The description is two sentences, front-loaded with the primary purpose, and uses precise, non-redundant language. It efficiently conveys the core function and key edge cases without 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?

Given the tool's complexity and lack of an output schema, the description covers essential behavior for listing and searching events, including recurrence handling. It omits details about pagination and output format, but these are not critical for invocation and are partially covered by parameters like cursor and pageSize.

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

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

The description explains the semantics of timeMin/timeMax and singleEvents, but the input schema has no property descriptions and the other seven parameters (accountId, calendarId, query, showDeleted, pageSize, cursor) remain undocumented. Since schema coverage is 0%, the description only partially compensates.

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 lists or searches events using query text in one selected calendar, with a verb, resource, and scope. It also differentiates from siblings by noting singleEvents:false reads underlying masters and exceptions, which distinguishes it from calendar_list_instances and calendar_get_event.

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 behavioral hints for when to use singleEvents:true vs false and requires offset-bearing time bounds for expanded occurrences. However, it does not explicitly name alternative tools or state 'use this instead of X', leaving some inference to the user.

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 important behavioral details: it uses Google occurrence IDs and originalStartTime, and it never synthesizes IDs or splits a series. This goes beyond the annotations by explaining internal mechanics and constraints. It does not contradict the readOnlyHint or destructiveHint annotations. It does not mention pagination or error behavior, but the disclosed information is substantial.

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, consisting of two sentences that directly address the tool's function and one key behavioral constraint. There is no excessive verbosity or redundant information. The structure is clear 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?

The description lacks essential context such as return format, pagination behavior, how deleted instances are handled (though showDeleted exists as a parameter), and how this tool differs specifically from calendar_list_events. Given the complexity of listing recurring instances, the description is incomplete for an agent to fully understand the tool's output and edge cases.

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

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

The description provides no explanation of any of the 8 parameters. While 'explicit time bounds' hints at timeMin and timeMax, it does not map parameters to their purposes, defaults, or requirements. With 0% schema description coverage, the description fails to add value for parameter understanding.

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 expands a recurring master event into its instances within explicit time bounds. The verb 'expand' is somewhat unusual but the context makes the purpose understandable. It does not explicitly differentiate from the sibling tool calendar_list_events, but the mention of 'recurring master' and the tool name provide some distinction.

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

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

The description does not provide explicit guidance on when to use this tool versus alternatives like calendar_list_events or calendar_get_event. It does not state preconditions, typical scenarios, or conditions that would favor this tool. The only guideline is implicit through the mention of 'recurring master,' but no explicit usage instruction is given.

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

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

The description indicates it modifies an RSVP and cannot affect others' responses, but does not elaborate on side effects like sending email updates or how recurrence scope affects past/future instances; annotations already flag it as non-read-only and destructive.

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 core purpose and concise requirements.

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?

Covers the operation, key requirements, and a limitation; without an output schema, return values need no explanation. It lacks detailed usage guidance but is sufficient for basic selection.

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?

Since schema description coverage is 0%, the description must compensate; it hints at some semantic constraints (self email identity, attendees, recurrence) but does not explain individual parameters like requestId, eventId, accountId, or responseStatus.

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 defines the tool as approving a participant-only self-RSVP on the user's own primary calendar copy, which distinguishes it from general event modification tools like calendar_update_event or calendar_create_event.

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 mentions requirements (exact email identity, complete attendees, recurrence scope, sendUpdates, human approval) and a limitation (cannot alter another person's response), but does not explicitly name alternative tools or conditions for choosing this tool over 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?

Beyond the destructiveHint annotation, the description discloses ETag usage, human approval requirements (except for continuous connector-private edits), and specific attendee handling that preserves responses. It also reveals failure behavior for series with persisted exceptions, providing substantial insight into side effects and concurrency control.

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 reasonably concise at three sentences but packs dense jargon such as 'Uses ETags and human approval except proven continuous connector-private edits' and 'Series with persisted exceptions fail closed.' The lack of separation between functional and behavioral aspects makes it harder to parse quickly.

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 (nested changes object, 7 required parameters, no output schema), the description fails to explain expected outputs, error conditions, or notification behavior (e.g., sendUpdates effect). It only hints at failure modes for series with exceptions, leaving an agent to infer too much about the tool's full behavior.

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

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

The description provides almost no direct explanation of any input parameters. It indirectly references event scope (default, series, occurrence) and attendee modes, but does not clarify accountId, calendarId, requestId, sendUpdates, or the many fields inside the changes object. With 0% schema coverage, this is a critical gap.

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

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

The description clearly states that the tool patches a single calendar event, explicitly distinguishing between default events, series, and recurring occurrences. It also specifies limitations (no arbitrary responseStatus/status) and the behavior for series with exceptions, leaving no ambiguity about the tool's core 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 implies use for updating an existing event (as opposed to create/delete) and highlights attendee add/remove/replace modes, but does not explicitly compare with sibling tools like calendar_create_event or calendar_rsvp. The 'fail closed' clause for series with exceptions gives a conditional hint but lacks guidance on alternatives.

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

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

The description says 'never send' and indicates a non-destructive draft creation, but the annotations declare destructiveHint=true. This is a serious contradiction about the operation's side effects, so transparency is undermined.

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

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

Three short sentences are front-loaded with the core purpose and give compact, relevant guidance without 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?

The description provides key retry semantics but misses important schema context such as the required text field, recipient structure details, and replyToMessageId. Given zero schema descriptions, this leaves significant gaps and includes a misleading statement about required recipients.

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

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

The schema has no property descriptions, and the description only explains requestId idempotency and mentions accountId and structured recipients. It omits required text and replyToMessageId semantics, and wording like 'structured recipients ... are required' conflicts with the schema, where to/cc/bcc are optional and text is required.

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

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

The description clearly states the operation with a specific verb and resource: 'Create a draft, never send.' This distinguishes it from the read/search/calendar siblings and clarifies the intended side effect.

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 useful usage context, especially idempotency guidance: 'Reuse the same requestId for retries; ambiguous creates are not retried.' It also emphasizes that the operation does not send, but it does not explicitly compare against alternative sibling tools.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false; the description adds valuable behavioral details beyond those: the 5 MiB read limit, base64 encoding, membership verification, and that no files are written or executed. It does not contradict the annotations, though it could clarify whether oversize attachments cause an error or truncated output.

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

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

Two tight sentences with no filler; the most important operational constraints (size limit, base64, safety) are front-loaded and every clause adds meaning. This is appropriately concise for a straightforward read operation.

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 lack of an output schema and the 0% parameter coverage, the description should explain more about the return value shape and how to select an attachment. It covers safety and size well, but leaves the agent without enough guidance on the exact parameters required to perform the read.

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

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

Schema description coverage is 0%, so the description must compensate, but it only says 'explicitly selected' and does not explain accountId, messageId, partId, or attachmentId. The required vs optional roles of these parameters remain unclear, especially how attachment selection actually maps to the available fields.

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

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

States a specific verb ('Read'), resource ('message attachment'), and key constraints (5 MiB limit, base64 output). Clearly distinguishes from sibling tools like gmail_read_message and gmail_read_thread by targeting attachment content rather than message/thread 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 phrase 'explicitly selected message attachment' implies the agent needs an attachment identifier and a parent message, but it never states when to prefer this tool over gmail_read_message or gmail_read_thread, nor does it mention prerequisites like first fetching attachment metadata. Usage context 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?

The description is transparent about behavior: it fetches only message-owned text bodies, excludes external images/resources and file attachments, and characterizes output as 'bounded, untrusted inert text.' It also implicitly signals no side effects (read-only), consistent with the readOnlyHint annotation. No hidden actions or limitations are omitted.

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, direct and free of extraneous detail. It efficiently packs the core action, the resource boundary, and the output nature without padding 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?

With no output schema, the description adequately explains the return shape: text content plus attachment metadata, and explicitly states what is not included (external resources, file attachments). It also conveys the trust boundary ('untrusted inert text'), giving the agent enough context to handle the result appropriately.

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 no property descriptions (0% coverage), so the description must compensate. It does partially: 'explicit account' implies accountId is a specific account identifier, and 'one message' implies messageId. However, it does not clarify the format, purpose, or constraints beyond the schema patterns, leaving some ambiguity for an agent.

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

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

Clearly states the action ('Read one message'), the resource ('one message from an explicit account'), and the scope (text bodies plus attachment metadata). The mention of 'bounded, untrusted inert text' and the exclusion of external resources/file attachments uniquely distinguishes this from a generic message reader, though it does not explicitly name sibling tools.

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

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

The description implies usage for fetching a single message's text and metadata, which is reasonably clear. However, it does not explicitly guide selection among siblings like gmail_search or gmail_read_thread, nor state when not to use it (e.g., for attachments or threads). The phrase 'from an explicit account' hints at requiring accountId but provides no comparative 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 readOnlyHint annotation, the description discloses important edge-case behavior: missing bodies are reported as incomplete, and oversized or failed reads fail clearly. This adds operational transparency not covered by 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?

Two concise sentences front-load the primary action and scope, then add error behavior. No filler or redundant phrasing; every word contributes to understanding.

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 simple input schema and no output schema, the description covers the essential behavior and error handling. However, it omits any parameter explanation and does not clarify the 'bounded' limit or how missing bodies manifest, leaving minor gaps for an agent to fill from parameter names.

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

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

The description does not explicitly explain any of the three parameters (threadId, accountId, maxMessages). It hints at accountId via 'explicit account' and maxMessages via 'bounded', but provides no direct mapping or detail, leaving schema coverage at 0%.

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

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

Clearly states the verb 'read' and the resource 'Gmail thread', with explicit scope ('bounded', 'from an explicit account') and content detail ('including message-owned text bodies'). This distinguishes it from single-message reads and searches without needing to name siblings.

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

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

Provides no explicit guidance on when to choose this tool over alternatives like gmail_read_message or gmail_search. The description implies its use case but does not state conditions or exclusions, leaving the agent to infer when a thread-level read is 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 mark the operation read-only and non-destructive, and the description adds meaningful behavioral details beyond that: per-account failures, query/account-bound continuations, and the warning that mail text is untrusted. These are non-obvious traits an agent needs to interpret partial results and handle pagination safely.

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 compact sentences front-load the core purpose and then list the most important behavioral caveats. There is no filler or redundant restatement of schema details.

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 read-only annotations and the schema's detailed parameter constraints, the description covers the key non-obvious aspects: bounded metadata, per-account failures, continuation binding, and untrusted content. It could be more complete about query syntax or the exact return shape, but the lack of an output schema is partially mitigated by 'bounded metadata'.

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

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

Schema description coverage is 0%, so the description carries the burden of explaining the five parameters. It only touches continuations with 'query/account-bound continuations' and implies accountIds through 'explicit accounts'; query, maxPages, and pageSize are left to the schema, which has no descriptions.

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

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

The description opens with 'Search explicit Gmail accounts', a specific verb plus resource that immediately identifies the tool as a search operation over a defined set of accounts. It also adds differentiating traits like bounded metadata, per-account failures, and continuations that separate it from sibling read tools such as gmail_read_message and gmail_read_thread.

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?

'Explicit Gmail accounts' signals when to use the tool: when the agent has specific account IDs to search, rather than listing accounts or reading a known message. It does not explicitly name alternatives or state when not to use it, but the intended context is clear.

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

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

Annotations already signal destructive behavior via destructiveHint=true, so the description adds value by clarifying the cancellation window and the irreversible boundary for dispatched actions. This goes beyond the structured annotations and helps the agent predict consequences.

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 short sentences with no wasted words. The main purpose is front-loaded, and the limitation is stated immediately afterward.

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 relatively simple with two required parameters and a destructive annotation already provided. The description covers the key behavioral boundary. It does not say how to obtain operationId or describe the return value, but the absence of an output schema and the low complexity keep this from being a major gap.

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

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

Schema description coverage is 0%, and the description does not explain accountId or operationId at all. The schema provides the operationId pattern and required fields, but the description contributes no additional parameter meaning or guidance.

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: 'Cancel a pending operation before dispatch.' It clearly differentiates this from operation_status by focusing on cancellation rather than status checks. The additional caveat about not undoing dispatched actions further sharpens the tool's 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 states when the tool is appropriate: for pending operations before dispatch. It also gives a clear exclusion: it does not undo already-dispatched actions. It does not explicitly name an alternative tool like operation_status, but the when/when-not guidance is still clear enough for an agent.

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 tool as read-only and non-destructive, and the description builds on this by warning about unknown outcomes. This adds valuable behavioral context beyond the annotations, though it does not detail return behavior or failure modes.

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 to the point, with no unnecessary words or repetition. It efficiently communicates the core action and a key safety caveat.

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

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

The description covers the basic action and a safety caveat, but it lacks details about what status values are returned, how to interpret the result, and what distinguishes a successful read from an unknown outcome. This leaves some gaps for an agent trying to fully understand the tool's behavior.

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

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

The schema has no parameter descriptions, and the description only indirectly references 'account' and 'write' without explicitly explaining accountId or operationId. Given the two required parameters, the meaning of operationId as the write operation identifier is not clearly conveyed.

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 the status of a write operation for a specific account, which distinguishes it from operation_cancel and other account-related tools. The phrase 'account's write' is slightly ambiguous but adequately conveys the core purpose.

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 includes a cautionary note about not blindly retrying unknown outcomes, which provides some usage guidance. However, it does not explicitly state when to use this tool versus alternatives like operation_cancel, leaving some inference required.

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