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

With no annotations supplied, the description carries the behavioral burden and does well: it discloses that a browser window opens on the server host and that the call blocks for up to 3 minutes awaiting sign-in. Missing pieces are what happens on timeout/failure and whether it returns the created account identifier.

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 action and the interactive constraint. The CLI sentence is dense and useful, though recommending an external command inside a tool description risks pulling the agent away from invoking the tool at all.

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

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

There are no annotations and no output schema, and the description covers the interactive/blocking nature well, but it leaves parameter meaning and return-value expectations undocumented. For an authentication tool that can hang for minutes, a note on timeout behavior and failure modes would round it out.

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% for both parameters, so the description must compensate. The CLI example at least surfaces the `--alias NAME --group GROUP` names, but it never explains what an alias or a group actually means, whether they are optional, or what happens when they are omitted.

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

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

The description gives a specific verb and resource: 'Connect a new Gmail account,' which clearly separates it from list_accounts, assign_account, and remove_account. It stops short of explicitly articulating the boundary with assign_account (which presumably attaches an already-authenticated account), so a perfect score isn't warranted.

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 does provide a routing hint by saying 'Prefer the CLI: gmail-mcp add-account ...', which tells the agent an out-of-band alternative exists. However, it never states when this MCP tool is the right choice (e.g., no CLI available, headless vs GUI hosts) or what to do if the browser cannot be opened.

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 supplied, the description carries the full burden. It does disclose two real behavioral traits: passing None clears the group, and groups are non-exclusive ('Many accounts may share a group'). It does not say whether re-assigning overwrites a prior group, whether the group must already exist, or anything about permissions or the response.

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 zero filler, and the core operation is front-loaded ahead of the null-clearing caveat and the shared-group note. Every clause adds distinct 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 two-parameter mutation tool with no annotations and no output schema, the description covers the operation, the clearing behavior, and the sharing model. Remaining gaps - overwrite semantics on re-assignment and the account identifier format - are minor but real.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for the non-obvious parameter: 'group' gets example values ('work', 'personal') and the critical null semantics. The required 'account' parameter is only implicit from the verb and its accepted format (ID vs. address) is never specified.

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 names a specific verb and resource ('Assign an account') plus the target concept ('to a group'), which is clearly distinct from siblings like add_account, remove_account and list_accounts. It stops short of explicitly contrasting itself with those siblings, but the operation is unambiguous.

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

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

Usage is implied rather than stated: the parenthetical '(None clears it)' tells the agent how to un-assign a group, which is a useful when-to-do-what hint. There is no explicit guidance on when to prefer this over remove_account or add_account, and no prerequisite or error-condition 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 supplied, the description carries the full behavioral burden, and it does disclose the single most important trait: nothing is transmitted. It says nothing about where the draft lands, whether recipients are validated, what happens on a bad address, or what the call returns (e.g., a draft id), so the disclosure is useful but shallow.

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, front-loaded with the action and its key constraint, with zero filler. Nothing could be removed without losing 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 mutation tool with no annotations, no output schema, and six undocumented parameters, the description should say more about result and side effects. The non-sending guarantee covers the highest-risk unknown, which keeps this from being inadequate, but the surrounding gaps remain.

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% across six parameters, so the description must compensate and it largely does not. Only `account` is explained ("an email or alias"); the format expected for the `to`/`cc`/`bcc` string arrays and whether `body` supports HTML are left entirely to inference.

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?

"Create a draft" is a specific verb+resource, and "(does not send)" immediately separates it from send_email and send_draft in the sibling list. It does not distinguish itself from create_reply_draft, which is the closest sibling, but the core action is unambiguous.

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

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

The parenthetical "does not send" implies the selection condition against send_email/send_draft, but only by negation. There is no explicit "use this when..." guidance and no mention of when to prefer create_reply_draft or send_draft for an existing draft.

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 supplied, the description carries the full behavioral burden, and it does disclose the most important trait: the draft is not sent. It says nothing about whether the draft lands in a Drafts folder, whether reply_all changes recipient handling, what account defaults to when omitted, or what 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?

Two short sentences, zero filler, with the core action and its non-sending nature front-loaded before the parameter note. Every clause carries information.

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

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

For a simple four-parameter draft-creation tool with no output schema and no annotations, the description covers the essential action and the non-send guarantee. It falls short on the reply_all semantics and on default account behavior, which an agent needs to call this correctly without guessing.

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 supply parameter meaning, and it only clarifies one of four: 'account is an email or alias'. The semantically loaded 'reply_all' flag is left completely unexplained (all recipients vs. sender only), and message_id/body get no elaboration.

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

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

The description uses a specific verb+resource ('Create a threaded reply draft to a message') and clarifies the key distinction from a send operation with '(does not send)'. It implicitly separates this from siblings like create_draft, reply_to_email, and send_draft, though it does not name any of them explicitly.

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

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

The parenthetical '(does not send)' implies the tool is for staging a reply rather than delivering it, which hints at when to use it over reply_to_email or send_draft. However, there is no explicit statement of when to choose this versus create_draft, nor any prerequisite or exclusion guidance.

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

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

With no annotations, the description carries the full burden. It usefully discloses the two-step preview/confirm safety flow and that attachments are carried along, but says nothing about permissions, whether the original is marked as forwarded, or what the preview contains.

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

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

Three short sentences, front-loaded with the action, then the two-step mechanic, then the one non-obvious parameter. No wasted wording.

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 5-parameter mutation tool with no annotations and no output schema, the description covers the critical confirm flow but omits body semantics, the array nature of `to`, and what the preview returns. Adequate but with clear gaps.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. It clarifies `account` (email or alias) and `confirm_token` (obtained from the preview call), but leaves `to`, `body`, and `message_id` entirely to the bare schema titles.

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

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

States a specific verb and resource ('Forward a message with its attachments'), which is clearly distinct from send_email and reply_to_email in the sibling list. It does not explicitly name those siblings, so it stops short of a 5.

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

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

Gives clear procedural guidance: the first call returns a preview plus confirm_token, and a second call with that token actually sends. It does not say when to prefer forwarding over send_email or reply_to_email, so no exclusions are covered.

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

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

No annotations are provided, so the description carries the full burden. It does disclose what comes back (headers, plain-text body, attachment names — notably not attachment content or HTML), which is real value, but it says nothing about read-only guarantees, permissions needed, or what happens when the thread or account is invalid.

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

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

Two tight sentences with the core action and returned fields front-loaded, followed by the one parameter clarification that needs it. Nothing is padded or redundant.

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

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

For a simple two-parameter read tool with no output schema, the description covers purpose and return shape adequately. However, with zero annotation and zero schema-description coverage it should also state the default-account behavior and any lookup-failure semantics, which it does not.

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 for both parameters. It clarifies that `account` is an email or alias, which the bare any-of string schema does not convey, but it leaves `thread_id` format undefined and does not say what happens when `account` is omitted (schema default is null).

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 ('Read all messages in a thread') and even enumerates the payload (headers, plain-text body, attachment names), so an agent can tell this fetches a whole thread by id rather than searching. It does not explicitly contrast itself with the sibling search_emails, which keeps it short of a 5.

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

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

Usage is implied: you call this when you already have a thread_id and want every message rather than a search result set. There is no explicit when-not guidance, no mention of when to prefer search_emails, and no note on prerequisites or failure behavior.

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

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

No annotations are supplied, so the description must carry behavioral disclosure. It says the tool lists connected accounts and mentions returned fields, but omits auth requirements, pagination or ordering, whether all accounts are returned, and any read-only safety context. For a no-annotation tool this is 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?

Single front-loaded sentence with no redundant wording. It communicates the resource and the surfaced fields 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?

For a zero-parameter list tool with no output schema, the description gives the core resource and fields but does not cover return shape, ordering, or pagination. It is adequate for a simple enumeration but leaves behavioral gaps.

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

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

There are zero input parameters, so the baseline is 4. The description's mention of email, alias, and group describes output fields rather than parameters and does not need to add parameter meaning.

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

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

States a specific verb, 'List', and resource, 'connected Gmail accounts', and names the surfaced fields (email, alias, group). The list verb clearly separates it from add_account, assign_account, and remove_account 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?

Implies usage by naming the resource to enumerate, but gives no explicit when-to-use guidance, prerequisites, or alternatives. An agent can infer it is the read path for accounts, yet the description does not state exclusions or when to prefer another sibling.

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 supplied, so the description carries the full disclosure burden. It reveals that results include subject and recipients, but says nothing about read-only nature, ordering, truncation, or how max_results caps the listing — significant gaps for a paginated list operation.

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

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

Two short sentences, front-loaded with the action and return fields, with no filler. The brevity is close to the limit of usefulness rather than wasteful.

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

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

For a simple two-parameter list tool with no output schema, the description covers the core action and one parameter but omits the result-limit behavior and any indication of what a draft entry looks like. Adequate but with clear gaps an agent would notice when calling 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?

Schema description coverage is 0%, so the description must compensate. It clarifies that `account` accepts an email or alias, which is genuinely useful, but `max_results` (default 10) is never mentioned, leaving half the parameters unexplained beyond their titles.

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

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

States a specific verb and resource ("List drafts") and even previews the returned fields (subject and recipients), so an agent can distinguish it from mutation siblings like create_draft or send_draft. It does not explicitly differentiate it from search_emails or get_thread, which keeps it from a 5.

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

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

There is no when-to-use or when-not-to-use guidance and no mention of the nearby alternatives such as search_emails for filtered retrieval. The listing intent is implied by the name, but routing between siblings is left entirely to inference.

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

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

With no annotations supplied, the description carries the full burden and does disclose the key traits: this is destructive (token revoked and deleted) and requires a two-step confirmation, which is the safety-relevant behavior. It omits what happens to any synced email/draft data and whether re-authorization is required afterward, leaving some destructive-side-effect detail unstated.

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; purpose and the destructive effect come first, then the two-step contract. Every clause earns its place.

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

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

For a destructive two-parameter tool with no annotations and no output schema, the description covers purpose, the destructive effect, and the confirmation handshake — enough to call it correctly. It is slightly short on post-removal state and error conditions, but nothing critical to invocation is missing.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: 'account' is defined as an email or alias, and 'confirm_token' is explained as a value returned by the first call and passed back on the second. It adds meaning for both parameters, though it doesn't describe accepted formats for the account identifier or validation failures.

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

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

States a specific verb and resource ('Disconnect a Gmail account') plus the exact mechanism ('revokes and deletes its stored token'). It is clearly separable from siblings like add_account, assign_account, and list_accounts without opening either schema.

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

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

The description gives the operative usage procedure — first call returns a confirm_token, second call with that token performs the removal — which tells the agent how to sequence invocations. It does not explicitly state when to prefer this over assign_account or what to do if the account is unknown, so it stops short of full when/when-not 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 behavioral burden, and it does disclose the important two-step preview/confirm safety gate before a mutation occurs. However, it omits side effects (does it mark the thread read, send immediately on confirm, apply to all recipients with reply_all) and failure behavior.

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

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

Three short sentences with no filler; the core action and the confirm flow are front-loaded. Nothing is redundant.

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 mutating, five-parameter tool with no annotations, no output schema, and zero schema descriptions, so the description needs to work harder than it does. It covers the confirm flow but leaves most parameters and the preview payload's shape unexplained.

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% across five parameters, and the description only explains `account` ('an email or alias') and implicitly `confirm_token` via the two-step flow. `message_id`, `body`, and `reply_all` receive no semantic explanation anywhere.

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

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

The description opens with a specific verb and resource: 'Reply in-thread to a message,' which distinguishes it from send_email (new message) and forward_email (forward). It doesn't explicitly contrast with the sibling create_reply_draft, so the agent must infer the draft-vs-send 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?

It gives concrete invocation guidance: the first call yields a preview plus confirm_token, and a second call with that token actually sends. That is a clear usage protocol. It does not state when to prefer this over create_reply_draft/send_draft or what to do if message_id is invalid.

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 at all, the description carries the full disclosure burden. It does add real behavior: the default scope spans all accounts, and each row reports its source account. It says nothing about result ordering, pagination, rate limits, or truncation behavior of max_results.

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

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

Three short sentences, front-loaded with the core action and query dialect, then scope, then return shape. No filler or repetition.

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

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

For a three-parameter read tool with no output schema and no annotations, the description covers query syntax, account scope, and result shape — the essentials. The undocumented `max_results` semantics and the absence of any output-shape details beyond the account field leave visible gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It does a good job on `account` (email, alias, or group; null means all) and on `query` (Gmail syntax with an example), but says nothing about `max_results` or its default of 10.

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

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

States a specific verb (search) plus the resource (messages/emails) and names the query dialect (Gmail search syntax with an inline example), so an agent knows exactly what the tool does. It does not distinguish itself from siblings such as get_thread or list_drafts, which is the only thing keeping it from a 5.

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

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

Gives one concrete usage rule — omit `account` to search across all accounts — which is genuinely actionable. It offers no guidance on when to prefer this over get_thread or list_drafts, and no exclusions or alternatives, so usage context is only implied.

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

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

With no annotations at all, the description carries the full burden and it does disclose the most important behavioral trait: a preview + confirm_token handshake before the irreversible send. It does not state irreversibility explicitly, mention permission needs, or describe what the preview contains or how tokens expire, which prevents a 5.

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

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

Three short sentences, front-loaded with the action and immediately followed by the non-obvious workflow. Nothing is redundant, though the `account` note reads as an afterthought appended after the workflow rather than integrated.

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

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

For a destructive, unannotated, no-output-schema tool, the description covers the critical two-step mechanic but omits what happens on a bad or expired token, whether the send is reversible, and what the preview returns. These gaps matter given the absence of annotations and output schema.

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

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

Schema coverage is 0%, so the description must compensate, and it explains both `account` (an email or alias) and `confirm_token` (obtained from the first call and required on the second). `draft_id` is left entirely undocumented, and no format or sourcing guidance is given for it.

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

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

"Send an existing draft" gives a specific verb and resource, and the word "existing" distinguishes it from create_draft/create_reply_draft and from send_email, which would compose-and-send in one step. It stops short of naming those siblings explicitly, so the differentiation is implicit rather than stated.

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

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

The two-step invocation is clearly spelled out, which is the main usage guidance an agent needs. However, there is no statement of when to prefer this over send_email, nor any prerequisites such as the draft needing to exist in the given account.

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

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

With no annotations, the description carries the full burden, and it does disclose the most important trait: sending is gated behind a preview + confirm_token round trip, so the first call is effectively non-destructive. It stops short of stating that the second call is irreversible, what the preview contains, or whether account/permission prerequisites exist.

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, front-loaded with the verb and the flow, with zero filler. It is slightly too terse in the phrase "call again with it," which leaves the agent to infer that the same payload plus the token is required.

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

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

For an irreversible mutation tool with no annotations and no output schema, the description covers the crucial confirm-token mechanism, which is the main failure mode. It still omits permission/authentication expectations, error behavior, and what the preview returns, leaving meaningful gaps for a 7-parameter write tool.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate and largely does not. It only explains `account` (email or alias) and partially explains `confirm_token` via "call again with it"; to/cc/bcc/subject/body are left to name inference, and the description does not clarify that the second call must repeat the original arguments.

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

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

States a specific verb and resource: "Send a new email." That is enough to distinguish it from sibling draft/reply tools such as create_draft, send_draft, and reply_to_email, though the description never names those alternatives explicitly.

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

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

The two-step preview/confirm flow is real usage guidance that an agent must follow to avoid an accidental send. However, there is no guidance on when to prefer this over send_draft, create_draft, or reply_to_email, and no exclusions or preconditions are given.

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