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

No annotations are provided, so the description carries the full burden. The verb 'List' strongly implies a read-only, side-effect-free operation, and the description states what will be returned. However, it does not explicitly confirm whether any authentication, refresh, or external network access occurs.

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

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

A single, front-loaded sentence that states the action, scope, and relevant output fields with no filler. Every word earns its place.

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

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

With no parameters and an output schema available, the short description is fully adequate. It tells the agent exactly what will be returned and is not missing critical information needed to invoke the 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 tool has zero parameters, so the schema provides no meaning to add. The description compensates by specifying the output fields (aliases and active status) and the scope ('all linked'), which is useful context 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?

The description uses a specific verb ('List') and names the exact resource ('all linked mcp-gmail accounts'), adding the aliases and active status fields. This clearly distinguishes account-list from siblings like account-me, account-switch, and account-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?

The phrase 'all linked' establishes a clear context: use this when you need the full set of connected accounts rather than the current one. It does not explicitly name alternatives or state when not to use it, but the sibling set makes the distinction reasonably obvious.

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly describes what the tool returns and implies a read-only, non-destructive operation through 'Show'. It does not mention authentication or error behavior, but for this simple zero-parameter identity query that is a minor omission.

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

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

Two short sentences with no filler. The core action is front-loaded, and the return fields are listed compactly.

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 zero parameters and the presence of an output schema, the description is complete: it states what the tool does and what information it returns. No further context is needed for such a simple 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?

There are no parameters, so the baseline is 4. The description correctly avoids inventing parameter details that do not exist.

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 (Show) and resource (current mcp-gmail user identity), and lists the returned values: email, alias, and session expiry. The word 'current' helps distinguish it from account-list, account-switch, and account-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?

The description implies its use: whenever you need the current user identity. However, it never explicitly says when to prefer this over account-list or account-switch, nor does it provide when-not-to-use 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?

With no annotations provided, the description carries the full burden of behavioral disclosure, and it delivers: it warns that stored tokens are deleted permanently, and explains the side effect where the first remaining account becomes active if the active account is removed. This is exactly the kind of destructive-action transparency an agent needs.

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 with zero filler: the primary action and permanence are front-loaded, followed by the active-account edge case and the parameter requirement. Every sentence earns its place and the structure prioritizes the most decision-relevant information first.

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 single-parameter tool with an output schema and no annotations, the description covers the essential ground: the destructive action, the active-account edge case, and the required input. Minor gaps remain, such as what happens when the last account is removed, but nothing critical is missing for correct invocation.

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

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

Schema description coverage is 100%, and the schema already defines accountId as 'Email address or alias of account to remove'. The description's closing sentence ('Requires email or alias parameter') merely restates the schema's required field and its format, adding no new semantic detail beyond the structured data.

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 ('Remove') with a clear resource ('mcp-gmail account') and states the permanent consequence ('delete stored tokens permanently'). This clearly distinguishes it from sibling tools like account-switch, account-list, and account-me, which cover different account operations.

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 context is implied rather than explicit: the tool is clearly for removing accounts, and the active-account fallback rule gives situational context. However, it never names alternatives or states when-not-to-use it (e.g., when the user only wants to switch accounts rather than delete one), so it stops short of explicit routing 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?

With no annotations, the description carries the full burden and largely succeeds: it discloses the OAuth trigger, the no-OAuth fast path, and the return payload (account email, newly-added flag, total count). It omits potential blocking/waiting behavior during the OAuth browser flow, but the main side effects are stated.

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: three sentences cover behavior, conditions, and return values. It is mostly front-loaded, but 'smart mode' is an unexplained term that adds confusion without earning 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 output schema exists and the two optional parameters are fully documented, the description is reasonably complete. It explains OAuth behavior and return fields, but leaves 'smart mode' undefined and does not mention session-level side effects of switching accounts, which would be useful for an agent deciding whether to call this 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%, giving a baseline of 3. The description adds meaning by explaining that email/alias can target an already-linked account and switches without OAuth, while absence of an email triggers account addition. This clarifies the relationship between the two optional parameters beyond their individual 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 specifies the action (switching to or adding a Gmail account) and the resource (mcp-gmail account). It clearly differentiates from siblings like account-me, account-list, and account-remove by describing its switch/add behavior, though the phrase 'smart mode' is vague and slightly obscures the primary 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?

It provides explicit conditional guidance: if an email/alias is already linked, switch without OAuth; if unlinked or no email provided, trigger OAuth. This is clear context for when to use the tool, though it does not name alternative tools for account listing or removal.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. The verb 'List' makes the read-only nature clear, and the description states what the tool returns ('IDs and descriptions'). For a simple listing operation, this is sufficient 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 a single, focused sentence that front-loads the action and resource. Every word adds useful information: 'Gmail', 'category labels', 'CATEGORY_*', 'IDs', and 'descriptions'.

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 low-complexity, zero-parameter read-only listing tool with an output schema available. The description fully explains what the tool returns and which labels it covers, leaving no critical gap for an agent to successfully select and invoke it.

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 input schema is empty, so there are no parameter semantics to document. The description does not need to compensate for schema gaps, and the baseline for zero-parameter tools is appropriately 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 uses a specific verb ('List') and identifies the exact resource ('Gmail category labels (CATEGORY_*)') plus the returned fields ('IDs and descriptions'). This clearly distinguishes it from sibling tools like labels-list, which handle user-created labels rather than Gmail's built-in CATEGORY_* labels.

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 by specifying that this tool handles Gmail category labels, not ordinary labels. It does not explicitly name alternatives or state when not to use it, but the CATEGORY_* qualifier makes the intended use unambiguous.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states 'Add', implying a mutation, but does not disclose idempotency, prerequisites, whether labels must already exist, or any side effects. The output schema may cover return values, but the description adds no 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 a single, front-loaded sentence with no wasted words. Every word contributes to identifying the operation and target resource.

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 low-complexity 2-parameter tool with full schema coverage and an output schema, the description is mostly sufficient. It leaves usage routing implicit and could mention that the label must already exist, but the schema hint about gmail-labels-list mitigates this 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 100%, with clear parameter descriptions for both id and label. The description itself does not add parameter-level detail beyond the schema, 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 states a specific action ('Add') and resource ('label to a Gmail message'). It is immediately distinguishable from sibling tools like label-delete and labels-list based on the operation described.

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

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

There is no description-level guidance about when to use this tool versus alternatives. The schema's label parameter mentions using gmail-labels-list to discover labels, but the description itself does not provide when/when-not conditions or 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?

Since no annotations are provided, the description carries full behavioral disclosure responsibility. It explicitly warns that deletion is permanent and irreversible, and that system labels will not work. It does not mention side effects on messages, but the core risk is well covered.

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: the first states the action and severity, the second adds the critical system-label exclusion. Every word earns its place, and the most decision-relevant 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?

For a single-required-parameter tool with an output schema and sibling context, the description supplies the essential operational constraints: irreversible deletion and the inability to delete system labels. It does not explain where label IDs come from, but that is reasonably implied by sibling tools like labels-list.

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 sole parameter, ids, is already fully described in the input schema as 'Gmail label IDs to delete.' The description adds little param-specific meaning beyond schema coverage, 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 opens with a specific verb and resource: 'Delete Gmail labels permanently.' The irreversibility warning adds important scope, and the tool is immediately distinguishable from label-add, labels-list, and message-move-to-trash.

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 clearly communicates when not to use the tool: system labels like INBOX and SENT cannot be deleted. However, it does not explicitly mention alternative sibling tools or broader conditions for when deletion is appropriate, so it lacks a full alternatives-based guideline.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds one useful operational detail: case sensitivity. It does not mention read-only status, pagination, authentication, or potential errors, though the output schema likely covers the return shape. The description gives moderate transparency but relies heavily on the tool's simple name.

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 very short and front-loaded: 'List Gmail labels' immediately states the action and object. The extra detail about query syntax and case sensitivity is relevant and non-redundant. The only minor issue is the compact phrasing 'for label: query syntax,' which is slightly awkward but not padded.

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

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

For a zero-parameter listing tool with an output schema present, the description provides the essential purpose and a key caveat about case sensitivity. It does not confirm exhaustiveness or Gmail-specific limitations, but nothing critical appears missing for selecting and invoking 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 tool has zero parameters, and the input schema fully documents this with 100% coverage. The description does not need to explain inputs, and the baseline for a zero-parameter tool is 4. No additional parameter context 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 identifies a specific verb ('List') and resource ('Gmail labels') and ties them to a concrete use case ('label: query syntax'). This distinguishes it from sibling tools like label-add and label-delete. However, the phrasing 'for label: query syntax' is slightly elliptical and could be misread as filtering by label rather than listing labels intended for use in queries.

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 this tool: when an agent needs Gmail label names for constructing label: query syntax. It does not explicitly compare with categories-list or explain when not to use it, leaving some inference to the agent. This is adequate but not fully 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?

No annotations are provided, so the description carries the behavioral burden. 'Get' signals a read-only operation and 'flexible field selection' indicates configurable output, but it does not disclose details like whether fetching marks the message as read or how omitted fields behave. This is adequate 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, front-loaded sentence with no filler. It names the action, resource, key constraint, and a meaningful capability all in one concise clause.

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 straightforward retrieval tool with a fully documented input schema and an output schema available, the description plus schema covers the essential calling context. It lacks explicit mention of authentication or preconditions, but these are not unusual omissions 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?

Schema description coverage is 100%, so the schema already documents all four parameters. The description's phrase 'flexible field selection' aligns with the fields parameter but adds no new semantic detail beyond what the schema 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 (Get), names a concrete resource (Gmail message), and identifies the selection mechanism (by ID). It also adds the differentiator 'flexible field selection,' which helps distinguish it from sibling tools like message-search or messages-export-csv.

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 the use case: retrieve a single Gmail message when an ID is known. It does not explicitly contrast with alternatives or state when not to use it, but the 'by ID' qualifier provides sufficient context against the 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?

No annotations are provided, so the description carries the full burden. It states the action but does not disclose effects beyond the phrase itself, such as idempotency, whether state is permanently changed, or any authorization requirements. This leaves behavioral context thin.

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

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

The description is a single, front-loaded sentence with no filler or redundant detail. Every word contributes to the core meaning.

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

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

For a simple one-parameter mutation with an output schema present, the description is mostly sufficient. It could add explicit behavioral notes, but the low complexity and complete schema coverage mean an agent is unlikely to be misled.

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 only parameter, id, is already documented as 'Gmail message ID to mark as read.' The tool description adds no parameter-level meaning beyond the schema, so the 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 uses a specific verb and resource: 'Mark a Gmail message as read.' It clearly distinguishes from sibling tools like message-move-to-trash and message-get, and leaves no ambiguity about 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 use case is implied: call this when a message should be marked read. However, the description does not explicitly contrast with alternatives or state when not to use it, so guidance is minimal but present.

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

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

No annotations are provided, so the description carries the behavioral burden. It adds the key disclosure that trashing is recoverable, which is useful context beyond the bare operation. It does not detail any permissions or side effects, but the behavior is simple and the recoverable note is the most important trait for an agent to know.

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

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

A single, front-loaded sentence that conveys the action, object, and a behavior qualifier with zero waste. It is concise without losing necessary 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 one-parameter tool with an output schema and full schema description coverage, the description is sufficiently complete. It explains the action and key behavior, and the schema covers the parameter. A richer note about Gmail's trash retention period could add value but is not essential.

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 provides 100% coverage with a description for the single 'ids' parameter. The tool description adds no additional parameter-related meaning, 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?

The description states a specific verb ('Move'), a resource ('Gmail messages'), and a destination ('to trash'), making the tool's function unmistakable. It naturally distinguishes itself from sibling tools like message-get, message-mark-read, label-add, and account tools, none of which involve trashing messages.

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 sets the context for use: this is the tool for moving Gmail messages into the trash. It does not explicitly name alternatives or exclusions, but the action is distinctive enough among the sibling tools that an agent can infer when to select 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?

With no annotations, the description carries the full burden of disclosing behavior. It indicates a side effect (sending) but does not clarify whether recipients/subject are derived automatically, what happens to the original message, or whether auth/permissions are required.

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

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

The description is a single concise sentence with no filler, and the core action is front-loaded. It earns its place entirely.

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 schema fully covers parameters and an output schema exists, but the description lacks annotations and adds no behavioral or usage context. For a simple one-action tool this is adequate but leaves nontrivial gaps around selection and side effects.

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 tool description itself adds no parameter-level meaning, but the schema already documents id, body, and contentType, including the enum and default for contentType.

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 ('Send a reply') and resource ('a Gmail message'), making the basic purpose clear. It does not explicitly contrast with sibling tools like message-send, though the word 'reply' differentiates it by implication.

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 given on when to use this tool versus message-send or whether the caller must first fetch the message to obtain an ID. Usage is only implied by the tool name and one-sentence description.

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

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

With no annotations present, the description carries the burden of behavioral disclosure. 'Search' clearly implies a read-only operation, which is useful context. However, the description does not disclose caveats such as the rawGmailQuery bypassing schema validation, response pagination behavior, or that messages are not modified.

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, and it front-loads the core action ('Search Gmail messages'). It is effective for a surface-level understanding, though it leaves room for more decision-useful 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 schema is rich and an output schema exists, so those cover invocation and return details. The description itself is thin for a tool of this complexity: it doesn't explain when to use this search tool versus message-get, and it omits any mention of raw Gmail query support or the relationship to other Gmail tools.

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 seven parameters thoroughly. The tool description adds only a high-level mention of structured query objects and field selection, which is helpful but not necessary for parameter-level 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 searches Gmail messages, which distinguishes it from siblings like message-get, message-send, and labels-list. It also mentions structured query objects and flexible field selection, giving a sense of the tool's unique capability. It falls short of a 5 because it doesn't explicitly contrast itself with message-get or other retrieval 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 verb 'Search' implies when to use this tool, but the description provides no explicit guidance on when to prefer it over alternatives like message-get or messages-export-csv. No exclusions, preconditions, or fallback recommendations 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says an email is sent, with no mention of side effects, authentication requirements, delivery guarantees, or whether sending is reversible. This is comparable to a minimally described mutation tool with no safety 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 a single, front-loaded sentence with no filler or redundancy. It immediately communicates the tool's function and earns its place without unnecessary elaboration.

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?

Even though an output schema exists and the input schema is well described, the one-sentence description does not address when to send a new message versus replying via message-respond, nor does it set expectations about delivery behavior. Given the sibling set and absent annotations, the context is incomplete for reliable tool 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 input schema provides 100% coverage, including descriptions for all six parameters, comma-separated formatting for recipients, and the contentType enum. The description itself adds no parameter-specific meaning, so the 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 states the specific action (send), the resource (email message), and the channel (Gmail), making the core purpose immediately clear. However, it does not explicitly distinguish this from sibling message-respond, which also involves composing an email, so it misses the final point for full sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. Sibling tools such as message-respond and message-search are present, but the description never mentions them or clarifies that message-send is for new outbound emails. This leaves the agent to infer the correct usage context.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses two non-obvious behaviors: streaming pagination and returning a file URI rather than inline data. These tell the agent that the operation may be long-running, handles large result sets incrementally, and produces a file reference. It does not explicitly state that the operation is non-destructive, but 'export' strongly implies a read-only action, so this is a strong disclosure given the 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 three short clauses, front-loads the core action, and each sentence adds a distinct fact: the operation, the pagination behavior, the return format, and a pointer for constructing queries. There is no redundant wording or unnecessary detail, making it easy for an agent 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?

For a tool with five parameters and a complex query schema, the description plus the detailed schema covers most essentials. The mention of streaming pagination and file URI return addresses two important runtime aspects not obvious from the schema. Minor gaps remain, such as how the returned file URI is intended to be consumed (e.g., temporary link vs persistent file) and when the query-syntax prompt is available, but the presence of an output schema likely covers return-value details.

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 of the five parameters (query, filename, maxItems, contentType, excludeThreadHistory) having a detailed description. Per the calibration baseline, this yields a 3 even though the description adds no parameter-level semantics. The mention of a query-syntax prompt is an external reference, not a substitute for the schema's own parameter documentation.

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 and resource: 'Export Gmail messages to CSV.' This clearly differentiates the tool from sibling tools like message-search or message-get because it specifies the operation (bulk export), the output format (CSV), and the return type (file URI). Even without naming siblings, the agent can confidently identify when this tool is the right one.

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

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

The description gives no explicit when-to-use guidance or comparison to alternatives. The only usage hint, 'Use query-syntax prompt for query reference,' directs the agent to external documentation for building queries but does not say when to choose this tool over message-search or message-get. The intended use case is only implied by the 'Export... to CSV' phrasing.

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