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 meaningful work: it discloses the 25 MB attachment cap, that local files are read from disk, that subject/to default from the original message when replying, and critically that nothing is sent. It omits error/permission behavior and what the returned draft object looks like, but the side-effect boundary is stated clearly.

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

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

Three compact sentences, front-loaded with the core action, followed by threading behavior and then the no-send guarantee. Every clause conveys distinct operational information with no repetition of the schema.

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

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

For a 7-parameter creation tool with no annotations and no output schema, the description covers the essentials an agent needs: what is created, attachment limits and local-file access, reply threading and defaulting rules, and that sending is out of scope. Remaining gaps (return value) are minor since the tool's contract is about producing a reviewable draft.

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 86%, so baseline is 3, but the description adds real semantics beyond the schema: reply_to_message_id implies subject defaults to Re: <original> and to defaults to the original Reply-To/sender (or original recipients), which the schema does not state. It also clarifies the attachment size constraint and that attachments are local file reads.

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+resource ("Create a plain-text Gmail draft") and immediately distinguishes it from sibling draft tools by noting it never sends mail and that the draft is reviewed in Gmail. The scope qualifiers (plain-text, optional attachments, threading via reply_to_message_id) let an agent separate it from update_draft or read_draft without consulting the schema.

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

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

It gives clear usage context: use reply_to_message_id to make the draft a threaded reply, and the MCP never sends so the user must review in Gmail. It does not, however, explicitly say when to use create_draft vs update_draft (e.g., editing an existing draft) or name an alternative, leaving that to inference from sibling names.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the no-attendees limitation and date-formatting behavior, including exclusive all-day end dates, but it does not cover permissions, side effects, response behavior, or what happens with existing events.

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 tightly written sentences with no waste. The core purpose is front-loaded, followed by the important formatting constraints.

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 and no output schema, the description gives enough formatting detail to invoke it correctly, but it leaves gaps around permissions, side effects, error behavior, and return values. It is adequate but not fully complete.

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

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

Schema description coverage is low at 14%, and the description compensates by clarifying the non-obvious semantics of start/end and all-day event handling. However, it does not explain other parameters such as summary, location, description, or calendar_id beyond what their names or the schema already convey.

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

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

The description uses a specific verb and resource: 'Create a Google Calendar event'. It also states a key scope constraint, 'with no attendees', which makes the tool's purpose immediately clear and distinguishes it from calendar read/update/delete 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?

The phrase 'with no attendees' implies when the tool is appropriate and when it is not, but there is no explicit guidance to choose between this and alternatives such as update_event or respond_to_event. Usage is implied rather than fully spelled out.

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

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

With no annotations, the description carries the full burden, and it does disclose one real side effect: deleting a shared event may notify attendees. However, it omits irreversibility/recoverability, required scopes, and whether recurring instances or the whole series is removed — significant gaps for a destructive 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 core action, and the side-effect caveat follows immediately. Nothing is redundant or 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?

Minimally adequate for a destructive tool with no annotations and no output schema: the agent knows what it deletes and one side effect. It still lacks irreversibility, permission requirements, and recurring-event scope, which an agent needs before invoking a delete.

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 no meaning for either parameter; event_id has no schema description at all, and calendar_id's default behavior is documented only in the schema. At 50% coverage the description should compensate but does not.

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 ('Delete one Google Calendar event') with an explicit cardinality scope ('one'). The verb cleanly separates it from get_event, create_event, update_event, list_events, and respond_to_event without needing to name them.

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

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

No guidance on when to use this versus update_event or respond_to_event, no prerequisites (permissions, ownership, calendar_id resolution), and no exclusions such as recurring-event handling. The agent must infer all selection criteria.

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 discloses key traits: it writes to local disk, defaults to a temp path, overwrites when no path is given, returns the saved path, and warns that attachment content is untrusted. It does not describe authentication or permission requirements, but the core mutation and overwrite behavior is clear.

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 tight sentences, front-loading the primary action and then adding the default path/overwrite behavior and the untrusted-content warning. Every sentence contributes useful information without 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 five-parameter tool with full schema coverage and no output schema, the description covers what the tool does, where it saves by default, that it returns the saved path, and that attachment data is untrusted. It stops short of describing authentication prerequisites or failure cases, but it is sufficiently complete for correct selection and invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful meaning beyond the schema by explaining the default save location when path is omitted and the default overwrite behavior, which are important for invoking the tool correctly.

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 and resource: save one Gmail message or draft attachment to local disk and return the saved path. It also scopes the operation to one attachment, distinguishing it from broader email-reading tools and generic file 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 usage is implied by 'Save one attachment of a Gmail message or draft to the local disk,' but the description gives no explicit when-to-use guidance or alternatives such as read_email, read_draft, or download_file. An agent can infer the context, but the routing is not explicitly stated.

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

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

With no annotations provided, the description carries the full behavioral burden and does well: it discloses default save location, overwrite behavior for the default path, export format mappings, and a key trust warning about untrusted content. It omits permissions requirements, error behavior, and any size or rate limits, which keeps it from 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?

The description is four compact sentences, front-loaded with the core action and return value. Each sentence adds distinct value: export formats, default path behavior, and the untrusted-content warning. There is no filler.

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

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

There is no output schema, but the description explains the return value ('the saved path') and covers the major operational details an agent needs: supported export formats, default save location, overwrite semantics, and trust level of downloaded content. It could be more complete by mentioning authentication requirements or common failure modes, but it is largely sufficient.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds meaningful operational context: it explains the default path behavior when no path is supplied and notes that the default location overwrites. The overwrite parameter is also contextualized by the distinction between explicit paths and the default path, though the interaction is not fully spelled out.

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 and resource ('Download a Drive file to the local disk') and clarifies the return value ('return the saved path'). It distinguishes itself from metadata tools like get_file and from download_attachment by naming Drive file export behavior and listing the exact export formats for Docs, Sheets, Slides, and Drawings.

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: use this to save a Drive file locally rather than to inspect metadata. However, the description never explicitly says when to use this instead of get_file or search_files, nor does it name any alternatives or exclusions. The guidance is adequate but not proactive.

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, yet it only vaguely gestures at behavior via "normalized details" without explaining what normalization means, whether it is read-only (implied only by the name "get"), what happens when the event is missing, or what permissions are required. For a tool with zero annotation coverage this is a significant disclosure gap.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity contributes to the tool's under-specification.

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

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

There is no output schema, so the definition should describe what "normalized details" actually contains, and with no annotations it should also indicate read-only semantics and failure behavior. Neither is covered, leaving an agent unable to predict the response shape.

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 both event_id and calendar_id (including the "defaults to primary" behavior) documented in the schema. The description adds no syntax or format detail beyond that, so baseline 3 applies.

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

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

"Get normalized details for one Google Calendar event" states a specific verb, resource, and cardinality, which distinguishes it from list_events and the mutation siblings. It stops short of explicitly naming an alternative, but the single-event scope 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?

There is no when-to-use guidance, no mention of when to prefer list_events versus this tool, and no note about preconditions such as access to the calendar. The agent must infer usage purely from the name and schema.

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 adds a non-obvious constraint: created_by_app is true only for files this app created, and those are the only files it can modify. It does not cover auth requirements, error behavior, or rate limits, but the permission/modifiability detail is valuable context beyond the schema.

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

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

The description is a single sentence that front-loads the core action and immediately follows with the key caveat about app-created files. Every clause earns its place with zero waste.

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 single-parameter read tool, the definition is nearly sufficient, but without an output schema it only names one returned field (created_by_app) and does not indicate what other metadata is included or how missing files are handled. The context is adequate but has clear gaps for an agent relying on return values.

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

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

Schema coverage is 100% and the sole parameter (file_id) is fully documented in the schema. The description adds no parameter-specific meaning beyond that and only mentions created_by_app, which is a return field rather than an input. Baseline 3 is appropriate when the schema already does the heavy lifting.

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

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

The description states a specific verb ('Get') and resource ('normalized metadata for one Drive file'), making the core action clear. It is distinguishable from listing tools like search_files and content-fetching tools like download_file because it targets metadata for a single file, though it does not explicitly name those 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?

The description implies a retrieval use case for file metadata, but it gives no explicit when-to-use, when-not-to-use, or guidance on choosing among alternatives like search_files or download_file. The usage context is only inferable from the verb and resource.

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, yet it discloses only that results are limited to calendars visible to the authorized account. It says nothing about pagination, ordering, whether secondary/holiday calendars are included, or what the response looks like — a notable gap for a zero-annotation tool.

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

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

A single front-loaded sentence with no filler, which is good, but its brevity reflects under-specification rather than disciplined economy — nothing about the call's behavior is established.

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 read tool with no annotations and no output schema, the definition leaves the agent without pagination behavior, default page size, or result shape. The account-scoping clause is the only substantive context provided.

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 50%: page_token is documented in the schema while max_results has only bound constraints and no meaning. The description does not compensate for that gap and never mentions either parameter, so an agent gets no help on what max_results defaults to or how paging should be handled.

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

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

States a specific verb and resource ('List the Google calendars') plus a scope qualifier ('visible to the authorized account'). It is clearly distinct from the email/file/event siblings, though it never names a sibling (e.g., list_events) to disambiguate calendar-level vs event-level listing.

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

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

There is no guidance on when to call this versus list_events or get_event, no prerequisites, and no note on whether it is a discovery step before other calendar operations. Usage is only inferable from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the shape of each returned summary row and that bodies/attachments are excluded, but it never states read-only safety, pagination behavior, or default page size for a 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 sentences, no filler, and the returned-field summary is front-loaded before the sibling routing. Every clause supplies something an agent can act on.

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 and no annotations, the description partially compensates by enumerating the returned fields and directing deep reads elsewhere. It stops short of noting pagination semantics or the default for max_results, which matters for a paged list 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 67%: query and page_token are described in the schema, max_results has bounds but no description. The description adds no parameter-level meaning (no query syntax notes, no page-size guidance), so the schema remains the primary source.

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

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

States a specific verb (List) and resource (Gmail drafts) plus the fields returned (recipients, subject, snippet, has_attachments), which sharpens the concept beyond a bare listing. It also names the sibling read_draft so an agent can distinguish shallow listing from full retrieval.

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

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

Explicitly routes the agent: use read_draft for the full body and attachment list, and reuse the returned draft_id with update_draft. That supplies both the alternative and the condition that selects it, leaving nothing 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, the description must carry the full burden, and it does disclose two useful traits: results are compact metadata rather than full messages, and the default scope is the inbox. It omits read-only nature, whether spam/trash are included, the 50-item cap, and pagination behavior beyond what the page_token field already implies.

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, no filler, and the core purpose is front-loaded before scope and query syntax 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?

For a list tool with no output schema and no annotations, the agent still lacks knowledge of what fields 'compact metadata' contains and what max_results defaults to. The essentials for invocation are present, but return-shape and limit details are thin.

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

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

Schema coverage is 67%: query and page_token are documented in the schema, while max_results has no description anywhere. The description's note about Gmail search syntax and the inbox default adds modest meaning beyond the schema's own example, so the baseline 3 fits.

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+resource ('List personal Gmail messages') and adds scope detail ('Defaults to the inbox', 'compact metadata') that separates it from siblings like read_email and list_drafts. It stops short of explicitly naming those alternatives, so an agent must infer the routing.

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 says to use Gmail search syntax in the query and that the default scope is the inbox, which implies when to use it. There is no explicit when-not guidance or reference to read_email/read_thread/list_drafts for different needs, so the agent is left to infer boundaries.

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 whole burden: it usefully discloses two defaults (calendar and date window), which is real behavioral value. However it says nothing about pagination despite a page_token parameter, nothing about result ordering or shape, and nothing about rate limits or permissions.

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

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

Two sentences, zero waste, and the core purpose is front-loaded ahead of the default behavior. Nothing is padded or repeated.

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

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

For a six-parameter, zero-required listing tool with no output schema and no annotations, the description covers purpose and the two important defaults. It stops short on pagination workflow and how to page through large ranges, which is the one thing an agent still has to infer.

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 83%, above the 80% threshold, so the schema already documents start, end, search, page_token, and calendar_id. The only parameter the schema leaves bare is max_results, and the description doesn't fill that gap; the calendar default it mentions merely restates calendar_id's schema text.

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 calendar events') plus a scope ('in a time range'), so the agent can tell it apart from get_event, which singles out one event. It never names a sibling explicitly, so differentiation is implied by the plural 'list' 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 default behavior ('primary calendar and the next seven days') hints at typical usage, but nothing says when to prefer this over get_event or list_calendars, and there are no exclusions or prerequisites. Guidance is implied rather than spelled out.

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

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

With no annotations, the description carries the full disclosure burden. It usefully specifies the returned payload (headers, plain-text body, attachment list, implying no HTML body), but says nothing about behavior on an unknown draft_id, permission/scope requirements, or whether the draft state is altered.

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

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

A single front-loaded sentence with the identifier first and the return contents after the colon. Every clause earns its place; 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?

For a single-parameter read tool with no output schema, the description covers the essential contract by enumerating the returned fields. Only the error/empty case and permission context are unaddressed, which are minor gaps for a simple 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 coverage is 100%, and the schema already explains the only parameter's provenance ('Draft ID from list_drafts or create_draft'). The description merely restates 'by draft_id', adding no extra syntax or format meaning, so baseline 3 applies.

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

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

States a specific verb and resource ('Read one Gmail draft') and goes further by listing exactly what is returned (headers, plain-text body, attachment list). This clearly distinguishes it from list_drafts and from read_email/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?

The 'by draft_id' phrasing and the schema hint ('from list_drafts or create_draft') imply the tool is used after enumerating or creating a draft, but the description never states when to prefer this over list_drafts or update_draft. Usage 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?

With no annotations, the description carries the full burden, and it does disclose useful behavior: the body is decoded text, attachments are returned as metadata with part_id, draft message IDs are accepted, and the content is flagged as untrusted. It does not state whether HTML-only bodies are converted or how errors like an invalid ID are surfaced, leaving minor gaps.

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

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

Three short sentences, front-loaded with what is returned, followed by the draft-ID caveat and the trust warning. Every sentence adds distinct information with no filler.

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

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

For a single-parameter read tool with no output schema, the description adequately covers the return shape by naming headers, decoded body, and attachment fields. It could say a bit more about missing-message behavior or body-format edge cases, but nothing critical to correct invocation is absent.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning beyond the schema's bare 'Gmail message ID' by clarifying that a draft's message_id is also accepted. That is a real semantic addition, though it does not explain ID format or sourcing.

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?

It names a specific verb and resource ('Read one Gmail message') and enumerates exactly what comes back: headers, decoded text body, and an attachment list with named fields. The phrase 'one Gmail message' also distinguishes it from the sibling read_thread, which operates on an entire 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?

The description implies when to use it by scoping to a single message and noting that draft message_ids work, but it never names an alternative (read_thread, read_draft) or states when not to use it. Usage is inferable but not explicitly guided.

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

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

With no annotations, the description carries the full behavioral burden. It adds useful context by stating chronological ordering, attachment lists, and that message content is untrusted data, but it does not disclose permissions, pagination/truncation behavior, or what happens when max_messages is omitted or exceeded.

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 with no wasted text. The core purpose is front-loaded, and the security warning is concise and relevant.

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 and no annotations, the description adequately conveys the return shape and a key security caveat. It remains incomplete on max_messages semantics and pagination/truncation behavior, which an agent would need to invoke it correctly.

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

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

Schema description coverage is only 50%: thread_id is documented, but max_messages has no description beyond min/max constraints. The tool description does not mention max_messages at all, so it fails to compensate for the schema gap or explain default/limit behavior.

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

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

The description states a specific verb and resource: reading a Gmail thread, with chronological ordering and attachment lists. It is clear enough to distinguish from sibling tools like read_email by resource, though it does not explicitly name when to prefer this over read_email.

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 that this tool is used to read a Gmail thread, but it gives no explicit guidance on when to use it versus read_email, list_emails, or read_draft. There are no exclusions, prerequisites, or alternative-routing instructions.

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, so the description carries the full burden. It does usefully disclose that an RSVP is transmitted to the organizer, a real side effect beyond a local write, but says nothing about permissions, visibility of the optional comment, or whether re-responding overwrites a prior 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 the action and its consequence front-loaded; every clause earns its place and nothing is 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?

With no annotations and no output schema, the agent must rely on the description for behavior, and it omits what the call returns, whether a comment accompanies the RSVP, and what the required response values mean in context. Incomplete for a 4-parameter mutation 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 only 25%; only calendar_id is documented. The description adds no meaning for event_id, the response enum, or the optional comment field (e.g. whether the comment is sent to the organizer), so it fails to compensate for the coverage gap.

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

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

A specific verb set (accept/decline/tentative) applied to an invitation, plus the side effect of sending the RSVP to the organizer. This clearly separates it from the generic update_event sibling, though it never names the resource as 'event' 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?

Usage is implied by 'invitation' and the RSVP framing, but there is no explicit when-to-use guidance, no statement of prerequisites (e.g. must be an invitee), and no routing against update_event or delete_event.

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 load. It usefully discloses that trash is excluded, that reads span the entire Drive, and that file content is untrusted data — a real security caveat. But it says nothing about result ordering, default page size (25) semantics, or permission/auth requirements for a search that may traverse shared content.

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 scope; the query example and the untrusted-data warning each earn their place. No filler.

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

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

With no annotations and no output schema, the description must cover behavior alone. It covers scope and a security note but leaves return shape (file ID, name, mimeType), ordering, and pagination flow unspecified — enough for a basic call, thin for correct iterative 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?

Schema coverage is 67%; the description's query example ('name contains resume') duplicates what the schema already states for that parameter and adds no syntax guidance beyond it. page_token and max_results are documented only in the schema, and max_results' 1-100 bound and default go unmentioned here.

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

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

States a specific verb and resource ('Search Google Drive') and pins the scope precisely: My Drive and Shared with me, trash excluded. It implicitly separates the tool from the file siblings (get_file, download_file, update_file) but never names an alternative, so it falls just short of full sibling differentiation.

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

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

'Drive reads cover the whole Drive' hints at cost/breadth and the trash exclusion implies a retrieval use case, but there is no explicit statement of when to use this instead of get_file or download_file, and no prerequisites or exclusions beyond trash.

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 burden and does so: it discloses data loss (Gmail formatting lost, inline images become attachments), attachment replacement rules, and that the draft gets a new message_id. It also tells the agent no mail is actually sent, which prevents a serious misinterpretation of 'update'.

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?

Patch behavior is front-loaded in the first clause, followed by attachment rules, then the destructive formatting caveat, then the no-send guarantee. Five dense sentences, none 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 an 8-parameter mutation tool with no annotations and no output schema, the description covers the side effects an agent must weigh before calling: field preservation, clearing semantics, attachment replacement, formatting loss, and new draft identity. Nothing required to invoke it correctly 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 coverage is already 88%, so baseline is 3, but the description adds semantics the schema does not: an empty recipient list clears the field, and attachments follow replace-by-filename rather than append. The body being rewritten as plain text clarifies the body parameter's effect.

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: 'Change only the supplied fields of one Gmail draft', with patch semantics made explicit. It implicitly distinguishes from create_draft via 'omitted fields are kept', but never names the sibling, so an agent must infer the create-vs-update routing rather than read it.

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

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

Clear usage context: partial updates, empty list to clear a recipient field, existing attachments retained, same-name file replaces. The 'MCP never sends mail; the user reviews and sends from Gmail' line sets the workflow boundary. No explicit exclusion naming create_draft as the alternative for new drafts.

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 patch semantics, the start/end pairing rule, and the attendee-notification side effect of mutating shared events, but says nothing about permissions, whether unspecified fields are preserved, or how recurring-event instances are affected — a major concern for a calendar mutation.

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 purpose, then the key constraint, then the risk note. Every sentence earns its place with no filler.

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

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

For an 8-parameter mutation tool with no annotations, no output schema, and near-zero schema description coverage, the description leaves too much unsaid: recurrence handling, timestamp format, permission requirements, and set-vs-clear semantics for optional fields are all 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 coverage is only 13% (just calendar_id is documented), so the description must compensate. Apart from the start/end coupling rule, it adds no meaning for summary, location, description, all_day, or event_id — notably absent are the time format/timezone for start/end and how to clear a field.

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 first sentence names a specific verb and resource ('Partially update one Google Calendar event') and 'partially' signals patch semantics, distinguishing it from create_event and delete_event. It doesn't explicitly name a sibling as its alternative, so it falls 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?

'Supply start and end together' is a genuine usage constraint, and the attendee-notification note flags when extra care is warranted. However, there is no guidance on when to choose this over create_event or respond_to_event, no prerequisites, and no exclusions.

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

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

With no annotations, the description carries the burden and does well: it discloses the destructive overwrite ('Replace the contents'), the 100 MB cap, exactly what is preserved (ID, link, sharing, revision history), and the refusal condition. It omits required permissions/scopes and error behavior, which matters for a mutation tool.

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

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

Three short sentences, front-loaded with the core action and scope, then the refusal rule and transfer direction. No wasted prose; the trailing clause about reading the local file is useful but sits slightly oddly at the end.

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 overwrite semantics, size limit, preservation guarantees, and the eligibility gate. Missing only permission/scope expectations and any hint of what is returned.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The line 'This reads the given local file' adds directional clarity about path (source, not destination) but no further syntax or constraints beyond the schema.

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

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

States a specific verb and resource ('Replace the contents of a Drive file') with concrete scope: only files this app created, up to 100 MB. The 'replace ... keeping its ID' framing implicitly separates it from upload_file (new file) without naming the sibling 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?

Gives a clear precondition and an explicit exclusion ('Refuses files the app did not create (created_by_app is false)'), which tells the agent when this call will fail and should be avoided. It does not name upload_file as the alternative for new files, so routing is left partly 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, the description does real work: it discloses the 100 MB limit, that it reads the local file, that writes are scoped to app-created files, and where the file lands by default. It does not address overwrite/duplicate-name behavior or permission requirements, which keeps it from 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 tight sentences, front-loaded with the core action and size limit, followed by placement and the sibling routing hint. No repetition of schema content and nothing wasted.

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

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

For a mutation tool with no annotations and no output schema, the description covers action, source, size cap, destination default, and write scope. It leaves return value and name-collision behavior unstated, which is a minor gap rather than a blocking one.

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

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

Schema coverage is 100%, so the schema already documents all four parameters clearly. The description adds only the location of the default mcp_default folder (My Drive root) and reinforces that path is read locally; that is a marginal supplement, so the baseline 3 applies.

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

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

States a specific verb and resource (create a new Drive file from a local file), adds a size bound, and explicitly contrasts with update_file, so the agent can distinguish it from siblings like download_file or update_file without opening any schema.

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

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

It names the alternative for the common confusion case (modifying an uploaded file → update_file) and states the default destination behavior. There is no explicit when-not guidance beyond that single alternative, so it is strong but not exhaustive.

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