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

With no annotations, the description carries the burden of disclosing behavior. It reveals that including attendees sends calendar invitations and requires confirm: true as a safety gate, which is a key side effect beyond the tool's name. While it doesn't cover every possible behavior, the most critical risk is disclosed.

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

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

The description is two concise sentences, with the main purpose in the first and the critical safety condition in the second. It is front-loaded, has no unnecessary words, and every sentence adds value.

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

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

For a create operation with 11 parameters and no output schema, the description covers the most important behavioral context (the confirm/attendees safety gate) while relying on the schema for parameter details. It is complete enough for an agent to avoid the main pitfall, though it could optionally mention auth or 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?

The schema already documents all 11 parameters with 100% coverage, providing a baseline of 3. The description adds meaningful semantic value by explaining the cross-parameter constraint that attendees require confirm: true, which isn't evident from individual parameter descriptions. This elevates the score.

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 'Create a new Google Calendar event' with a specific verb and resource, clearly distinguishing it from sibling tools like calendar_update_event, calendar_list_events, and calendar_delete_event. The added detail about confirm for attendees further clarifies the action's scope.

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

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

The description provides clear context for when to use the tool (creating new events) and explicitly states the condition under which confirm must be true (when attendees are included). However, it does not explicitly mention alternatives or when not to use this tool, so the guidance is clear but lacks explicit 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 a heavier burden. It discloses a key behavioral consequence (attendees will be notified of cancellation) and the confirm requirement, but it does not mention whether deletion is permanent, how it affects recurring events, or what happens if confirm is false. Partial disclosure only.

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: the first states the purpose, the second explains the confirm requirement. It is front-loaded, concise, and every sentence earns its place with no redundancy.

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

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

Given the absence of annotations and output schema, the description is arguably minimal for a delete operation. It covers the essential confirm behavior but omits important operational details such as permanence, error conditions, and what the response contains. Still, it's better than nothing, earning a middle score.

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

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

Schema coverage is 100% for all four parameters, so the baseline is 3. The description adds meaning beyond the schema by explaining why confirm is needed ('since they will be notified of the cancellation'), providing additional context for the confirm parameter that the schema only hints at.

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 'Delete a Google Calendar event,' which clearly identifies the verb (delete) and resource (Google Calendar event). It distinguishes from sibling tools like calendar_update_event and calendar_create_event, and adds a critical condition about the confirm flag for events with attendees.

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

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

The description clearly implies when to use this tool (when deleting an event) and provides specific guidance about the confirm parameter for events with attendees. It doesn't explicitly mention alternatives or exclusions, but the context is sufficient for an agent to select this tool over siblings.

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

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

No annotations are provided, so the description carries the full burden. It clearly indicates this is a read-only status check and adds context about supporting multiple calendars and a time range. While it doesn't discuss edge cases or auth requirements, the behavior is straightforward and well disclosed for a safe operation.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose. No redundant words or filler; it is front-loaded with the key action and resource.

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

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

Given the tool's simplicity and the lack of an output schema, the description covers the core behavior sufficiently. It mentions the time range and multiple calendars, but does not describe the return format or handle edge cases. However, for a free/busy check, this is acceptable and complete enough for an agent to select and invoke the tool correctly.

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

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

The input schema covers all parameters with 100% description coverage, so the schema already provides meaning. The description adds slight context about multiple calendars but does not elaborate on the parameters beyond what the schema states. Thus, it meets the baseline but does not exceed it.

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

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

The description clearly states the tool's function: checking free/busy status for one or more Google Calendars within a time range. It uses a specific verb (check) and resource (free/busy status), and the scope is explicit. This distinguishes it from sibling calendar tools like calendar_list_events or calendar_get_event, which handle event details.

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

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

The description implies usage for checking availability but does not explicitly state when to use this tool versus alternatives. It lacks direct comparisons or exclusion criteria, making the usage context inferable rather than clearly 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?

No annotations are provided, so the description alone must convey the operation's nature. The verb 'Get' clearly indicates a read-only, non-destructive action, but the description does not disclose expected return format, authentication needs, or error behavior. It adds minimal context beyond the operation's safety.

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

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

The description is a single, front-loaded sentence that directly states the action and resource without unnecessary words. It is maximally concise and well-structured.

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

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

Given the tool's simplicity and full schema coverage, the description adequately conveys the tool's core function. However, it omits a note about the default calendarId ('primary') and the nature of 'full details', but these are minor gaps for a straightforward retrieval tool.

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

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

Schema description coverage is 100%, with each parameter (eventId, accountId, calendarId) already has a clear description. The tool description adds no additional parameter-level semantics beyond what the schema provides, so baseline 3 is appropriate.

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

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

Description uses a specific verb 'Get' and clarifies the resource as 'full details for a specific Google Calendar event', clearly distinguishing it from sibling tools like calendar_list_events or calendar_search_events which handle multiple events.

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

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

The description implies this tool is for retrieving a specific event by ID but does not explicitly state when to prefer it over alternatives such as list/search, or note that it is read-only versus update/create/delete tools. Usage context is evident from the name but not articulated.

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 burden. It discloses that the tool lists primary, shared, and subscribed calendars, which gives a sense of scope and non-destructiveness. However, it does not mention authentication requirements, response format, or edge cases like empty results or hidden calendars, leaving some behavioral 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?

The description is a single, concise sentence that front-loads the action and resource. Every word earns its place, with no redundancy or filler.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is complete enough for an agent to select and invoke it correctly. It clearly states what is listed and the scope, making it self-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?

The schema covers 100% of the single parameter (accountId) with a clear description. The tool description does not add additional detail about the parameter, so the baseline of 3 applies since the schema already handles the semantics.

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

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

The description uses a specific verb 'List' with a clear resource 'calendars' and scope ('for a Google account'), and enumerates the calendar types (primary, shared, subscribed). This distinguishes it from sibling tools like calendar_list_events, so it fully clarifies the tool's purpose.

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

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

The description implies the use case: when you need all calendars associated with an account. There is no explicit alternative comparison, but the scope is well-defined and no exclusions are stated, providing clear context for when to use this tool.

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 discloses the core action (list) and the default calendar, but omits details about pagination, ordering, recurrence handling, or return format. For a read-only list operation, this is acceptable but minimal.

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 action and resource, zero filler. The description is perfectly concise and to the point.

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

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

Given the absence of annotations and output schema, the description is somewhat sparse. It does not explain pagination behavior or return structure, which are important for a list tool. However, for a simple list operation, the essential information is present.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no new parameter semantics; the default calendar mention duplicates the schema's own default description. No added value beyond what the schema already provides.

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

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

The description clearly states the verb 'list', resource 'events from a Google Calendar', and scope 'within a time range' with a default to primary calendar. This distinguishes it from sibling tools like calendar_get_event (single event) and calendar_search_events (search).

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

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

Provides clear context: listing events within a time range and default calendar. It does not explicitly mention alternatives or when not to use, but the context is sufficient for an agent to select it for straightforward range-based listing.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the core action but omits important details such as whether the event is removed from the source calendar, permission requirements, or effects on attendees. This is a significant gap for a mutating operation.

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

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

The description is a single clear sentence, front-loaded with the action and subject. Every word earns its place with no redundancy or verbose context.

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

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

Given the four parameters, no annotations, and no output schema, the description is too minimal. It does not mention the default source calendar behavior (though the schema covers it), potential side effects, or what the response will look like. An agent would need to infer critical operational details.

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

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

The schema already provides full descriptions for all four parameters (100% coverage). The description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate. It does not clarify relationships or default behaviors beyond what the schema states.

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

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

The description clearly states the action (move), the resource (Google Calendar event), and the destination (different calendar). It is specific and distinguishes itself from sibling tools like calendar_update_event or calendar_create_event.

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

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

The description does not provide any explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The use case is only implied by the action word 'move', but no direct comparison to related tools is given.

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

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

No annotations are provided, so the description carries the full burden. It discloses the core mutation (changing RSVP status) but does not mention side effects (e.g., whether the organizer is notified), permissions required, idempotency, or potential errors. This is a significant gap for a mutation tool with zero annotation support.

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

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

The description is a single sentence, front-loaded with the core verb and resource, and contains zero filler. Every word earns its place, making it highly scannable for an agent.

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 RSVP tool, the description is minimally viable, but it lacks critical contextual information such as prerequisites (user must be invited) and behavioral side effects. Given no output schema and no annotations, a bit more context about expected results or preconditions would improve completeness. It is adequate but not comprehensive.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters clearly. The description adds no extra meaning beyond what the schema provides; it merely repeats the enum values in natural language. Per the rubric, baseline 3 is appropriate when schema 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 clearly states the action ('Respond to a Google Calendar invitation') and the three response options (accept, decline, tentatively accept). This distinguishes it from sibling tools like calendar_update_event (which modifies event details) and calendar_get_event (which reads). However, it does not explicitly contrast with these siblings, so it misses the highest level of 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?

There is no guidance on when to use this tool versus alternatives. The description merely states what it does without explaining prerequisites (e.g., must be an invitation recipient) or when to prefer it over calendar_update_event. No exclusions or alternative tool references are provided.

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

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

No annotations are provided, so the description carries the full burden. It adds useful behavioral detail by listing the fields searched (summary, description, location, attendees), but does not disclose response format, pagination, auth requirements, or default behaviors beyond what the schema already indicates. For a read-only search tool, this is moderate but not comprehensive.

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

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

The description is two concise sentences with no filler. It front-loads the purpose and then adds search-scope detail in the second sentence. Every word earns its place.

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

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

Given the tool's moderate complexity (6 params, 2 required) and no output schema, the description sufficiently defines the tool's core function. It could mention return value or default time range behavior, but the schema already documents most parameters, so the description is adequately complete for a search tool.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific nuance beyond what the schema already provides (e.g., timeMin/timeMax, maxResults). It does not harm or further clarify the parameter meanings.

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

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

The description clearly states the tool's function with a specific verb ('Search') and resource ('Google Calendar events'), and specifies the search scope (summary, description, location, attendees). This distinguishes it from sibling tools like calendar_list_events, which lists events without text filtering.

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

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

The description implies when to use the tool: when you need to find events by text query across specific fields. It does not explicitly name alternatives or exclusion criteria, but the context is clear enough for an agent to differentiate it from the list/create/update event siblings.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses a major side effect—sending notifications to attendees—and the confirmation gate required to proceed. It could mention more about partial-update behavior or auth requirements, but the disclosed behavior is material and not inferable from the schema alone.

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

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

The description is a single, front-loaded sentence that immediately states the purpose and then highlights the critical confirmation requirement. There is no filler, repetition, or unnecessary detail.

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

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

For an 11-parameter mutation tool with no output schema and no annotations, the description conveys the core purpose and one important side effect, but omits return-value expectations, partial-update semantics, and permission requirements. The schema covers parameter details, so the description is adequate but not comprehensive.

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

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

The schema describes all 11 parameters at 100% coverage, so the baseline is 3. The description adds meaningful conditional semantics for the confirm parameter—requiring true when attendees exist or are added—which goes beyond the schema's generic wording. Other parameters remain schema-defined, but that is acceptable given full schema coverage.

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

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

The description clearly states the tool updates an existing Google Calendar event, using a specific verb and resource. It is easily distinguishable from sibling tools like calendar_create_event, calendar_delete_event, calendar_move_event, and calendar_rsvp.

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 specifies a key usage requirement: confirm must be true when attendees exist or are being added, because update notifications will be sent. It does not explicitly name alternatives or exclusions, but the context and sibling tool names make the appropriate use fairly clear.

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

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

With no annotations provided, the description is the sole source for behavioral disclosure. It only states the basic copy action and optional rename, but does not explain side effects (e.g., whether the copy lands in the same folder), required permissions, or the return value. This leaves significant ambiguity for a tool that creates a new resource.

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

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

The description is concise and front-loaded, with two short sentences that state the primary action and the key optional parameter. Every word adds value, and there is no redundant or extraneous content.

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

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

For a simple copy operation, the description covers the core action, but it lacks mention of return output, destination behavior, or any prerequisites. Given no output schema and no annotations, the description is not fully complete, though it is minimally sufficient for an experienced user.

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

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

Schema description coverage is 100%, and the description adds only that the new name is optional, which is already implied by the schema. It does not provide extra meaning or examples beyond the structured parameter descriptions, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Create a copy' and names the resource ('a file in Google Drive'), which precisely conveys the action. It clearly distinguishes from sibling tools like drive_rename_file and drive_move_file by focusing on duplication.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or cases where another tool (e.g., drive_rename_file) would be more appropriate.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It only states the action and gives no details about permissions, default parent folder behavior, error handling, or return value.

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

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

The description is a single, direct sentence with no superfluous information, making it well-structured and easy to parse.

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

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

The tool is simple and the schema fully covers parameters, but with no output schema and no behavioral details, the description is only minimally complete. It does not mention what happens on success or the returned folder ID.

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

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

The input schema provides complete descriptions for all three parameters (name, accountId, parentFolderId), so the description adds no additional parameter semantics. The baseline of 3 applies due to high schema coverage.

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

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

The description clearly states the action ('Create') and the resource ('a new folder in Google Drive'), which is specific and distinguishes it from sibling tools like drive_rename_file or drive_upload_file.

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

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

The description implies the tool's use case clearly but provides no explicit guidance on when to choose this over alternatives or any exclusions. Since no sibling tool creates folders, the context is straightforward but still not fully explicit.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It adds meaningful context about Google Workspace file export (Docs/Sheets/Slides to standard formats), which is a key behavior. However, it does not disclose other relevant behaviors such as overwrite semantics, authentication requirements, potential side effects, or return value, leaving notable 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?

The description is two sentences, tightly written with the primary action in the first sentence and a key nuance in the second. Every clause earns its place, and the most important information is front-loaded. No redundant language or filler.

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

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

For a straightforward download tool, the description covers the core functionality and an important edge case (Workspace export). It does not describe the return value or side effects, but the absence of an output schema and the simplicity of the operation make this acceptable. It is sufficiently complete to differentiate from related drive tools.

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

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

Schema description coverage is 100%, so the input schema already documents all four parameters including their descriptions. The main description adds minimal semantic value beyond the schema; it only reinforces the outputDir purpose ('save it to a local directory'). This meets the baseline but does not elevate it since the schema is complete.

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

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

The description clearly states the action (download) and resource (a file from Google Drive), and specifies the outcome (save to a local directory). It also distinguishes itself from sibling tools like drive_get_file_content or drive_get_file by focusing on downloading to disk. The additional note about Workspace file export further clarifies scope.

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

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

The description implies when to use this tool (when a local copy is needed) but does not explicitly contrast with alternatives like drive_get_file_content or drive_get_file. It lacks clear when-not-to-use guidance or mention of specific scenarios, so the usage context is implied rather than explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only lists return fields and does not mention permissions, error cases, access scope, or API behaviors. While 'Get metadata' implies a read operation, it offers no detail about what happens for inaccessible files or auth requirements.

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

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

The description is a single front-loaded sentence that begins with the action verb and packs relevant details without fluff. Every word earns its place.

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

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

For a simple metadata retrieval tool with only two fully documented parameters and no output schema, the description conveys the essential return scope. It is sufficient for an agent to select it, though it omits exact return structure and error behavior.

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

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

Schema coverage is 100%: both fileId and accountId have descriptions. The tool description adds no extra meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Get') and resource ('metadata for a Google Drive file') and enumerates expected fields (name, size, type, owners, sharing status). This clearly distinguishes it from sibling tools like drive_get_file_content or drive_download_file, which fetch content.

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

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

The metadata framing implies use when you need file properties rather than content, but there is no explicit when-to-use guidance or mention of alternatives. The description does not state exclusions, such as 'to download contents, use drive_download_file'.

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 discloses the truncation default (10,000 chars), the metadata returned (fileName, totalSize, truncated flag), and redirects users away for binary/large files. Missing are error conditions or auth specifics, but for a preview tool this is solid transparency.

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

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

Three sentences, front-loaded with the main purpose, followed by output summary and alternative guidance. No filler or repetition; every sentence adds value.

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

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

For a simple preview tool with no output schema, the description provides a complete picture: what it returns (truncated text + metadata), default behavior, and when to use other tools. The parameter schema handles input details, so nothing essential 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 100% with each parameter already described (e.g., maxChars 'Maximum characters to return (default: 10000)'). The description reiterates the default but does not add meaning beyond the schema. Meets the baseline for fully covered schemas.

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 ('Get a preview of file content from Google Drive'), establishes a default truncation length, and immediately distinguishes itself from sibling tools by naming drive_get_full_file_content and drive_download_file. This makes the tool's scope and intent 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?

Explicit guidance is provided: 'For full content use drive_get_full_file_content. For large/binary files prefer drive_download_file to save to disk instead.' This clearly states when to use this tool vs alternatives, exceeding the baseline requirement.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It warns that the response 'can be very large and may overload your context window', which is a critical behavioral trait that annotations would not capture. This is a significant, honest disclosure of a potential risk.

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

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

The description is a single, front-loaded sentence that immediately warns about the size issue, then gives a usage condition and alternatives. Every clause earns its place; there is no redundancy or filler.

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

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

For a simple but potentially hazardous read operation, the description covers the key context: the full-content nature, the risk of large responses, and the existence of safer alternatives. Since there is no output schema, the description adequately explains the return value as the entire file content. This is complete for an agent to make an informed decision.

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 additional meaning to the parameters beyond the schema, which already provides 100% coverage with descriptions for both accountId and fileId. The baseline of 3 applies because the schema does the heavy lifting, and the description doesn't need to compensate.

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 explicitly states 'Returns the ENTIRE file content' with a specific verb and resource, and it distinguishes itself from the sibling tools drive_get_file_content (preview) and drive_download_file. This clearly conveys what the tool does and how it differs from alternatives.

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 explicit usage guidance: 'Only use this when you genuinely need the complete file (e.g., for analysis or transformation)' and names the alternatives to prefer for browsing or saving large files. This tells the agent exactly when to select this tool and when not to.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explains the default folderId behavior, the ability to use a Shared Drive ID, and points to a sibling tool for discovery. This adds meaningful context beyond what schema provides, though it does not mention pagination or result structure.

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

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

The description is two sentences, front-loaded with the core action, and every sentence earns its place. It is concise, well-structured, and free of irrelevant detail, making it easy for an agent to parse quickly.

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

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

Given the tool's moderate complexity (4 parameters, no output schema), the description covers key usage contexts: default root, shared drive top-level, and sibling tool reference. It does not explain pagination or result contents, but the schema already documents pageToken and maxResults, so the description is reasonably complete for selection and invocation.

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

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

Although the schema already describes all parameters (100% coverage), the description adds valuable semantics for folderId: it explains the default My Drive root behavior and that a Shared Drive ID can be used for its top level. This goes beyond the schema's basic type/description and helps the agent use the parameter 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 clearly states the tool's function: 'List files in a Google Drive folder.' It specifies the resource (files) and the action (list), and distinguishes itself from siblings like drive_search_files by focusing on folder-based listing. It also clarifies default behavior and shared drive usage, making the purpose unambiguous.

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

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

The description provides guidance on when to use the tool: listing files in a folder, with default to My Drive root, and provides explicit instructions for Shared Drive top-level listing. It also references a sibling tool (drive_list_shared_drives) for discovering IDs. However, it does not explicitly contrast with search_files or other alternatives, so it misses some comparative guidance.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds membership scoping ('the user is a member of') and the relationship to other tools, but does not explicitly state read-only semantics, pagination behavior, or potential errors. Since 'List' clearly implies a read operation, the transparency is adequate but not enriched.

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

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

The description is two sentences, front-loaded with the primary action and immediately followed by the practical use of the results. No redundant information, every sentence earns its place.

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

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

The tool is simple and there is no output schema, but the description gives enough information for an agent to understand the result type (drive IDs) and how to chain it. It does not describe the full response structure, but the core purpose and downstream usage are covered, making it nearly 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 100%, so the schema fully documents parameters. The description adds no new parameter details, but it does explain how the output (drive IDs) maps to parameters of other tools, which is helpful context. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists Shared Drives the user is a member of, using a specific verb and resource. It differentiates from sibling tools by focusing on the drive listing and explicitly referencing how the results feed into drive_list_files and drive_search_files.

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

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

The description provides explicit, actionable usage guidance: use the returned drive IDs as folderId for drive_list_files or as driveId for drive_search_files. This tells the agent exactly when and how to use the tool's output, and implies the tool is the entry point for browsing/scoping shared drives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the basic action without mentioning side effects (e.g., whether the file is removed from the old folder), permission requirements, return values, or error behavior. This is minimal 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?

The description is a single sentence that is direct and to the point, containing no unnecessary information. It fully serves its purpose without redundancy.

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

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

For a simple move operation with fully documented parameters, the description is adequate for an agent to understand the core action. However, given the lack of annotations and output schema, it would benefit from mentioning the return value or any permission requirements, but this is not critical for successful invocation.

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

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

The input schema has 100% coverage with clear descriptions for all three parameters ('The file ID to move', 'The Google account ID, alias, or email', 'The destination folder ID'). The description adds no additional parameter semantics beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description clearly states the verb 'move' and the resource 'file to a different folder in Google Drive'. It distinguishes from sibling tools like drive_copy_file (copy) and drive_rename_file (rename) by specifying the destination folder.

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

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

The use case is implied by the verb 'move', but the description does not provide explicit guidance on when to use this tool versus alternatives (e.g., drive_copy_file) or any prerequisites. No exclusions or alternative tool mentions are present.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. However, it only restates the basic action without explaining any side effects, permission requirements, impact on shared links, or what happens to the file after renaming. This is a significant gap for a mutating operation.

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

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

The description is a single, front-loaded sentence with no filler words. Every word contributes to conveying the core purpose. This is appropriately concise.

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

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

The description is minimally adequate for a simple rename operation, but it omits any context about prerequisites, how accountId is used, or the outcome of the rename. Given the absence of annotations and output schema, it would benefit from at least a note on permissions or the effect on the file. This is not complete enough for a 4, but not as poor as a 2.

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%, meaning all parameters (name, fileId, accountId) already have descriptions. The tool description adds no additional meaning beyond the schema, but it does implicitly align with the 'name' parameter. Baseline 3 is appropriate.

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

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

The description clearly states the specific verb 'Rename' and the resource 'a file in Google Drive', which distinguishes it from sibling operations like move, copy, trash, and share. There is no ambiguity about what this tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites, permissions, or scenarios where renaming is appropriate. It simply states the action without context.

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

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

With no annotations, the description carries the full burden. It explicitly discloses the default search scope (My Drive + all Shared Drives), the conversion of shorthand type: queries to mimeType queries, and content: using fullText. It also mentions raw API query syntax. This goes beyond basic behavior, though it omits details like result fields or pagination limits 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 concise, front-loaded with the main purpose, and every sentence provides useful detail without fluff. It packs substantial information about scope, shorthand, and raw syntax into a compact paragraph.

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

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

Given no output schema and moderate complexity, the description is quite complete. It covers the main query semantics and scoping, but doesn't explicitly mention pagination behavior or the fields returned. Since there is no output schema, these are minor gaps, making 4 appropriate.

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

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

Schema coverage is 100%, so baseline is 3. The description adds significant value for the 'query' parameter by explaining shorthand syntax and fullText behavior, and for 'driveId' by clarifying the default scope. This raises the score above baseline.

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

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

The description clearly states the tool's purpose: 'Search for files in Google Drive.' It specifies both the action (search) and the resource (files), and distinguishes it from sibling tools like drive_list_files by emphasizing query-based search across multiple scopes. The detailed syntax options reinforce the distinct purpose.

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

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

The description gives clear context on when to use the tool: searching across My Drive and all Shared Drives by default, and how to restrict via driveId. It also points to drive_list_shared_drives for ID discovery. However, it doesn't explicitly contrast with drive_list_files or explain when to use one over the other, which would make it a 5.

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

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

With no annotations, the description carries the full burden and uses it well: it discloses that sharing exposes the file and requires confirm: true as a safety gate. This is valuable behavioral context beyond the schema. It does not detail all side effects, but the most critical safety aspect is articulated.

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 filler. The main purpose is front-loaded, and the confirm requirement is a crucial addition. Every word contributes to understanding the tool's function and its key caveat.

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

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

Given the tool has 8 parameters and no output schema, the description covers the essential behavioral contract: sharing equates to creating a permission and requires confirmation. The schema handles parameter details. It could mention the return value or consequences, but the current level is adequate for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning to the confirm parameter by labeling it a 'safety gate' and tying it to the exposure risk. This goes beyond the schema's simple boolean description, helping the agent understand why confirmation is mandatory.

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

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

The description clearly states the action: 'Share a Google Drive file by creating a permission.' This specifies the verb (share) and resource (Google Drive file) and distinguishes it from siblings like drive_rename_file or drive_update_permissions. The safety gate note adds specificity without confusion.

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 implicitly answers when to use: whenever you want to share a file. It does not explicitly mention alternatives or exclusions, but the action is clear. The confirm requirement also sets a prerequisite, which is useful guidance. However, it does not compare to drive_update_permissions, which could be an alternative for modifying existing permissions.

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 merely states the action without disclosing side effects like reversibility, permission requirements, or whether trashing is permanent. This is a mutation tool, and the lack of behavioral context is a clear 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?

The description is a single, concise sentence with zero wasted words. It is perfectly sized for the simple action it describes.

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

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

For a simple two-parameter tool with complete schema and no output schema, the description is minimally adequate. However, it could be more complete by noting the file is moved to the Drive trash (not permanently deleted) and possibly mentioning that the action is reversible.

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

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

The input schema covers both parameters with clear descriptions (fileId, accountId), so schema coverage is 100%. The description adds no extra parameter info, but the baseline for high schema coverage is 3.

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

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

The description clearly states the action ('Move') and the resource ('a file to trash in Google Drive'), making it distinct from siblings like drive_move_file or gmail_trash. It is specific and unambiguous.

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

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

The usage is implied from the description; it's obvious you use this tool to trash a file. However, there is no explicit guidance on when to prefer this over alternatives or any 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 full burden of behavioral disclosure. It does disclose the critical safety gate: 'Requires confirm: true as a safety gate since permission changes affect access control.' However, it does not explain consequences such as ownership transfer risks, reversibility, or auth requirements, leaving 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?

The description is two sentences, front-loaded with the primary purpose, and includes a critical usage note without fluff. Every word earns its place.

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

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

Without annotations or output schema, the description provides the core purpose and the confirm gate, but it lacks details on side effects (e.g., what changing to 'owner' implies, whether access is revoked). It is adequate for a simple permission update but leaves some behavioral context uncovered.

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 all parameters are described structurally. The description adds value by explaining why `confirm` is required (safety gate), which reinforces its semantic importance, but it does not add detail for other parameters beyond the schema.

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

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

The description clearly states a specific action: 'Update an existing permission on a Google Drive file.' This verb-resource pairing is unambiguous and distinguishes it from sibling tools like drive_share_file (which creates permissions) or drive_trash_file (which modifies file state).

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

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

The description implies this tool is used for updating permissions that already exist, but it does not explicitly contrast with drive_share_file (which creates new permissions) or mention when not to use it. The confirmation requirement is a usage gate, but alternatives or exclusions are not named.

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

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

With no annotations provided, the description carries the full burden. It discloses behavioral details such as the server reading the file from disk and isBase64 applying only to content. However, it omits potential mutation consequences (e.g., overwrite behavior), authentication needs, and error handling, leaving gaps for a write operation.

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

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

The description is two sentences, front-loaded with the core action, and contains no redundant information. Every phrase contributes essential usage instructions, making it highly concise and well-structured.

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

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

Given the tool has 7 parameters and no output schema, the description adequately covers input modes but does not explain what the tool returns (e.g., file ID) or error/conflict outcomes. This leaves the context somewhat incomplete for a tool of this complexity.

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

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

Schema coverage is 100% with individual parameter descriptions. The description adds meaningful value by clarifying the relationship between content, filePath, and isBase64, and noting that the server reads the file directly. This supplements the schema beyond what the property descriptions provide.

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 explicitly states 'Upload a file to Google Drive' with a clear verb and resource. It also distinguishes from sibling tools by detailing content delivery methods (UTF-8 text, base64, file path), making the purpose unambiguous.

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

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

The description provides clear usage context by explaining how to provide content (text, base64, or file path) and when to use isBase64. It implies use for uploading files to Drive but does not explicitly mention when not to use it or reference alternatives, which is acceptable for a direct upload tool.

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

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

Since no annotations are provided, the description carries the burden and does well: it discloses the core behavior (removal from INBOX), the persistence (All Mail), searchability, and a permission requirement ('full scope'). It could add details like idempotency or error handling, but the key behavioral facts are covered.

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

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

The description is only three sentences, front-loaded with the primary action, and every sentence adds value (effect, retention, requirement). No fluff or repetition.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential behavior, side effects, and requirements. It could mention what happens if the message is already archived or whether the operation is idempotent, but overall 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?

The schema covers 100% of parameters with clear descriptions for accountId and messageId. The description adds no additional parameter-specific detail, so the baseline of 3 applies.

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

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

The description uses a specific verb 'Archive' with a clear resource ('Gmail message') and explicitly states the action ('removing it from INBOX'). It distinguishes archive from trash or delete by noting the message remains in All Mail and searchable.

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

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

The description makes the semantic clear, implying it should be used for archiving rather than deleting. However, it does not explicitly mention when to use this tool versus alternatives like gmail_trash or gmail_modify_labels, nor does it provide 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 provided, the description carries the burden of disclosing behavioral traits. It does add valuable context: 'Limited to 1000 messages' and 'Requires full scope' inform about constraints and permissions. However, it does not disclose potential side effects, partial failure behavior, or the distinction between add and remove label operations beyond the schema. This is decent but not comprehensive.

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 concise sentences, each earning its place: purpose, efficiency argument, and key constraints (limit and scope). It is front-loaded with the primary action and contains no fluff or repetition.

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

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

Given the tool has 5 parameters, no output schema, and no annotations, the description provides moderate context. It covers purpose, efficiency, limits, and scope, but lacks explicit guidance on batch confirmation, error handling, or alternatives. For a bulk mutation tool, more detail would enhance completeness, but the description is not grossly inadequate.

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 each parameter already has clear descriptions. The description itself does not add additional semantic detail beyond the schema, except for reinforcing the 1000-message limit, which is also present in the messageIds parameter description. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Apply label changes to multiple messages in one operation.' This is a specific verb+resource combination that distinguishes it from sibling tools like gmail_modify_labels, which handles single messages. The scope is also clarified with 'multiple messages' and the 1000-message limit.

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

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

The description provides context for when to use this tool: 'More efficient than individual modifications' implies a bulk operation use case. It also notes the 1000-message limit and full scope requirement, which are important prerequisites. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the readonly scope requirement (auth need) and that it returns a manifest of saved files (output). This adds meaningful context beyond the tool name and schema, though it does not detail potential side effects like overwriting or long-running operations. The disclosure is solid for a straightforward download 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?

The description is three sentences long, with the primary action front-loaded. Every sentence adds value: the action, the return value, and the required scope. No redundant or extraneous information is present.

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

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

The description covers the core purpose, the return manifest, and the auth requirement. Given the tool's moderate complexity and full schema coverage, it is mostly complete. It does not describe the manifest contents or error handling, but these are not critical for the agent to invoke the tool correctly. The lack of an output schema makes the return-value mention particularly useful.

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

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

The input schema covers 100% of the four parameters with clear descriptions. The tool description does not add any parameter-specific semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Download') and clearly identifies the resource ('all attachments from one or more Gmail messages') and destination ('local directory'). This distinguishes it from sibling tools like gmail_get_attachment (single attachment) and gmail_list_attachments (listing only), making the tool's unique purpose immediately clear.

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

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

The description provides clear context for when to use this tool: for downloading all attachments from one or more messages in bulk. It implicitly contrasts with single-attachment retrieval tools but does not explicitly name alternatives or state when not to use it. This is clear context without exclusions, aligning with a score of 4.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool does not send the email immediately and requires specific permissions, making its non-destructive nature clear. It could add more detail on error handling or return value, but the key behavioral facts are present.

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

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

The description is three short sentences, front-loaded with the primary action. Each sentence adds distinct value: purpose, lifecycle context, and permission requirement. There is no redundant or filler content.

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

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

Given the tool's complexity (10 parameters, no output schema), the description covers the essential context: what it does, the draft lifecycle, and required scopes. The schema covers parameter specifics. It doesn't explicitly state what the tool returns (e.g., draft ID), but this is inferable from sibling tools and the draft lifecycle mention. Reasonably complete for a create operation.

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

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

The schema description coverage is 100%, with all parameters already explained in the JSON schema. The description itself adds no additional parameter-level meaning; it only mentions authorization scope, not parameter semantics. Since the schema handles parameter details, a baseline score of 3 is appropriate.

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

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

States 'Create a draft email' – a specific verb and resource. The second sentence clarifies the draft lifecycle (reviewed/updated/sent later), distinguishing it from immediately sending or from attachment-specific draft creation. This differentiates it well from siblings like gmail_send_draft and gmail_create_draft_with_attachment.

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 use when a draft is needed for later review or sending, and explicitly mentions the required OAuth scope ('compose or full scope') as a prerequisite. It gives clear context for when to use it, though it doesn't explicitly name alternative tools or exclusion 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 burden. It discloses key behaviors: attachment data can be base64 or file path (server reads from disk), draft is not sent immediately, requires compose/full scope, and max 25MB size. These go beyond schema details, but it doesn't mention return values or error handling.

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

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

Three sentences, front-loaded with the main purpose, and every sentence adds distinct information: purpose, attachment methods, lifecycle, auth, and size limit. No redundancy or filler.

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

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

The description covers the core purpose, attachment mechanics, authorization, and size constraints, which is strong for a create operation. However, since there is no output schema, it omits what the API returns (e.g., draft ID), leaving a minor completeness gap.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explaining the 'data OR filePath' distinction (explicitly stating OR and that the server reads the file) and introducing the 25MB total limit, which is not in the schema.

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

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

The description clearly states the tool's purpose: 'Create a draft email with file attachments.' It differentiates from sibling gmail_create_draft by explicitly mentioning attachments, and clarifies the draft can be reviewed and sent later, distinguishing it from send tools.

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

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

The description implies usage context by specifying it creates drafts (not sending) and supports attachments, which hints at when to use this over plain gmail_create_draft. However, it does not explicitly name alternatives or state when-not to use this tool, so it falls short of a 5.

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

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

With no annotations, the description carries the full transparency burden. It discloses two key behavioral aspects: it 'Requires settings scope and confirmation,' covering authentication and a safety gate. However, it does not detail side effects, idempotency, or post-creation behavior (e.g., immediate activation, return value), leaving some gaps in behavioral disclosure.

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

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

The description is two concise sentences, front-loaded with the main action, and every sentence earns its place. It avoids redundancy and effectively summarizes the tool's purpose and key requirements without unnecessary detail.

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

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

The tool has moderate complexity (nested objects, 4 required params) with no output schema or annotations. The description covers the essential operational context: what the tool does, the roles of criteria and actions, and the need for settings scope and confirmation. Given full schema coverage and clear sibling differentiation, this is sufficiently complete for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by explaining that 'Criteria define which messages match; actions define what happens to them,' providing conceptual grouping for the nested objects. It also highlights the 'confirm' parameter as a safety gate. Yet it doesn't elaborate on each field beyond what the schema already provides, so it stays at baseline.

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

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

The description clearly states the tool's purpose with a specific verb and resource: 'Create a Gmail filter to automatically process incoming messages.' It distinguishes this from sibling tools like gmail_list_filters and gmail_delete_filter by focusing on creation and explaining that criteria and actions define the filter's behavior.

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

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

The description gives clear context on when to use the tool (to automatically process incoming messages) and explains the roles of criteria and actions. However, it does not explicitly mention alternatives or when not to use it, such as pointing to gmail_list_filters for existing filters or gmail_delete_filter for removal. Still, the context is sufficient for correct selection among siblings.

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

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

With no annotations, the description carries the full burden. It adds value by noting 'Requires full scope', an auth requirement not present in the schema. However, it does not disclose return behavior, potential errors, or uniqueness constraints, which is a notable gap 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?

The description is a single, front-loaded sentence that states the action first, then optional settings, then a requirement. Every word earns its place with no redundancy.

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

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

The description is adequate for a simple create tool, but with no output schema and no annotations, it should ideally mention what is returned (e.g., the created label) or any duplicate-label behavior. It covers the essential details but leaves these 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 100%, so the schema fully documents all six parameters. The description groups some parameters as 'color and visibility settings', adding minimal semantic grouping but no unfamiliar detail beyond the schema.

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

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

The description clearly states a specific action ('Create a new Gmail label') and the resource (Gmail label), with optional color and visibility settings. This differentiates it from sibling tools like gmail_update_label and gmail_delete_label.

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

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

The description provides clear context for creating a new label, and the 'Requires full scope' gives a prerequisite. It does not explicitly mention alternatives or when not to use, but the create/update/delete sibling structure makes the use case obvious.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It simply states 'Delete a draft email' without noting whether deletion is permanent, reversible, or requires specific permissions. This is a significant gap 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?

The description is a single, clean sentence with no redundant wording. It is front-loaded and easy to read, though it falls short on informational content rather than conciseness.

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

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

For a destructive tool with no output schema and no annotations, the description is incomplete. It fails to address whether the deletion is permanent, confirms any side effects, or explains the result. Essential context for safe use 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?

The input schema already provides descriptions for both parameters (draftId and accountId) with 100% coverage. The tool description adds no additional meaning or context beyond what the schema already states, so baseline 3 is appropriate.

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

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

The description clearly states the action (delete) and the resource (draft email), which is specific and distinguishes this from sibling tools like gmail_create_draft, gmail_get_draft, and gmail_update_draft. It could not be confused with other 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?

No guidance is provided on when to use this tool vs alternatives such as gmail_trash or gmail_delete_label. There are no prerequisites or contextual cues, leaving the agent to infer usage entirely from the 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?

Since no annotations are provided, the description carries the full burden. It discloses the destructive nature ('Delete'), the required settings scope, and the confirmation safety gate. However, it does not state whether deletion is permanent or if any consequences apply beyond the filter itself, but the mention of scope and confirmation is substantial for a delete 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?

Two sentences with no wasted words. The core action and prerequisite are front-loaded, and the safety and auth notes are concise.

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

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

Given the tool's simplicity and lack of output schema, the description covers the necessary context: what it does, how to find the ID, the required scope, and the mandatory confirmation. It is complete for safe 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 descriptions cover all three parameters at 100%, so the baseline is 3. The description adds some value by advising to use gmail_list_filters to obtain filterId, and it reinforces the safety gate for confirm, but it does not add significant new meaning beyond the schema.

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

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

The description clearly states the action ('Delete'), the resource ('Gmail filter'), and the identifier ('by ID'). It distinguishes from siblings like gmail_create_filter and gmail_list_filters by specifying deletion.

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

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

It explicitly tells the user to use gmail_list_filters to see existing filters, which is a helpful prerequisite and alternative. It also mentions the confirmation requirement, but does not explicitly state when not to use it, though the context implies the need for an existing filter ID.

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 discloses key behavioral traits: messages keep existing and only lose the label, system labels are forbidden, and full scope is required. This is strong for a delete operation, though it doesn't mention return values or error scenarios.

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

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

The description is three short sentences, front-loaded with the main action ('Delete a Gmail label'), and every sentence adds value without redundancy.

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

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

For a simple delete tool with no output schema and no annotations, the description is complete enough: it states what it does, what it doesn't do to messages, restrictions on system labels, and permission requirements. Sibling tools show related operations, but the uniqueness is clear.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no extra meaning about parameters beyond the schema; for example, it doesn't explain the 'confirm' parameter, but the schema already does.

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 ('Delete') and resource ('a Gmail label'), clearly stating the action. It also adds distinguishing nuances: messages are not deleted, only the label is removed, and system labels cannot be deleted, which differentiates it from tools like gmail_trash or gmail_modify_labels.

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

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

Provides clear context, including that system labels cannot be deleted and that the operation requires full scope. It implicitly guides against using this tool when message deletion is intended by stating messages are not deleted. However, it doesn't explicitly name alternative tools like gmail_create_label or gmail_modify_labels.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the return format ('Returns file path and metadata (no binary data in response)'), the side effect of saving to disk, and the permission requirement ('Requires readonly scope'). It could add error-handling details, but the essential behaviors are covered.

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

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

The description is three sentences long, front-loaded with the primary action, and every sentence adds value. There is no fluff or redundancy.

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

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

For a tool with 4 required parameters, no annotations, and no output schema, the description provides the key context: the prerequisite workflow, return format, and read-only scope. It is sufficiently complete for an agent to understand the tool's behavior and usage.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add substantial parameter-level detail beyond the schema; the mention of using gmail_list_attachments is already captured in the filename parameter schema description.

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

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

The description clearly states the specific action: 'Download an attachment from a Gmail message and save it to local disk.' It uses a specific verb and resource, and distinguishes from siblings like gmail_list_attachments by referencing the prerequisite and return format.

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

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

It provides clear context by instructing 'Use gmail_list_attachments first to get filenames,' establishing a prerequisite workflow. However, it does not mention alternatives like gmail_bulk_save_attachments or explicitly state when not to use this tool.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns 'full content' and indicates a read-only intent via 'preview', but it does not explicitly state that the draft is not modified, nor does it mention any auth requirements or error behavior. This is adequate for a simple get operation but lacks depth.

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

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

The description is a single, concise sentence that is front-loaded with the action ('Get a draft email') and adds relevant context ('full content for preview before sending'). There is zero wasted text.

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

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

The description is clear but minimal. There is no output schema, so the description should explain return values; 'full content' is vague and does not specify whether attachments, headers, or metadata are included. It also omits potential error cases or prerequisites, making it only minimally complete for a simple tool.

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

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

Schema description coverage is 100% for the two parameters (draftId and accountId), so the baseline is 3. The description adds no additional parameter-specific information, providing no extra value beyond the schema.

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

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

The description uses a specific verb 'Get' and clearly identifies the resource as 'a draft email' with the purpose 'for preview before sending'. This distinguishes it from sibling tools like gmail_get_message and gmail_get_thread, which operate on non-draft messages.

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

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

The phrase 'for preview before sending' provides clear usage context, implying the tool is for retrieving drafts before they are sent. However, it does not explicitly mention alternatives or exclusions, such as 'use gmail_get_message instead for sent messages', so it falls short of fully explicit guidance.

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

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

With no annotations, the description carries the full burden. It accurately indicates a read operation ('Get') and states that headers and body content are included, but does not disclose potential side effects, auth requirements, or the impact of the 'format' parameter. It is minimally transparent but not misleading.

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

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

The description is a single, front-loaded sentence that immediately conveys the tool's purpose without filler words. Every word contributes meaning, making it highly concise and well-structured.

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

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

Given the simplicity of the tool and full schema coverage, the description adequately covers the core functionality. However, the absence of an output schema and lack of guidance about the 'format' enum's effect on return value leaves some gaps. It is sufficient but not rich.

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

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

The input schema fully describes all three parameters (accountId, messageId, format) with 100% coverage. The description adds no additional parameter-specific meaning beyond noting 'by ID', which is already covered by the schema. Baseline 3 is appropriate because the schema 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 clearly states the verb 'Get' and the resource 'a single Gmail message by ID', making its purpose specific and unambiguous. It also differentiates from siblings like gmail_get_messages_batch and gmail_get_thread by emphasizing 'single' and including 'headers and body content'.

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

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

The description implies use for retrieving one message at a time but does not explicitly contrast with alternatives like batch retrieval or thread retrieval. There is no mention of when to choose this tool over gmail_get_messages_batch or gmail_get_thread, leaving the guidance mostly 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?

No annotations are provided, so the description carries full behavioral burden. It mentions the 50-message limit, but this duplicates the schema's 'max 50' constraint. It does not disclose read-only status, error behavior, response format details, or any other side effects, leaving the agent with insufficient information for safe invocation.

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

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

The description is two sentences, front-loaded with the core action, and every word earns its place. It is concise and structured effectively, though the limit mention is redundant with the schema, it does not hurt clarity.

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, yet the description does not explain the return value shape or the meaning of the format enum values. It conveys the core purpose and limit, but lacks completeness for a batch operation where the response structure and format semantics are important.

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

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

Schema description coverage is 100%, with each parameter having a clear description. The tool description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool fetches multiple Gmail messages in a single call, with a specific verb ('Fetch') and resource ('Gmail messages'). It distinguishes from single-message fetch tools like gmail_get_message by emphasizing batch efficiency and the 50-message limit.

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 'More efficient than fetching individually' implies use when multiple messages are needed, providing clear context for preferring this over gmail_get_message. However, it does not explicitly name alternatives or state when not to use it, so it falls short of explicit 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?

No annotations are provided, so the description carries the full burden. It communicates the core behavior (returning a thread and all its messages) but does not disclose additional traits such as response format, potential size, or authentication requirements. However, as a read-only get operation, the risk is lower, making a score of 3 appropriate.

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

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

The description is a single sentence that is both concise and informative. It front-loads the key action and resource without any extraneous words or redundancy.

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

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

For a simple read tool with a clear name and schema, the description sufficiently explains the tool's purpose. It does not detail return values, but the phrase 'with all its messages' gives enough context. The absence of an output schema and the presence of a format parameter make the description slightly incomplete, but it remains solid.

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

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

The input schema provides complete descriptions for all three parameters, including the format enum. The description adds no extra semantic information beyond what the schema already states, so the baseline of 3 applies.

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

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

The description clearly states the tool 'Get a Gmail thread with all its messages', specifying both the action (get) and the resource (Gmail thread). This distinguishes it from sibling tools like gmail_get_message (which retrieves a single message) and gmail_search_messages (which finds threads).

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

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

The description implies usage (when you need a complete thread) but does not explicitly state when to use it versus alternatives. It lacks exclusions or references to sibling tools, so the guidance is only implicit.

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 discloses a key behavioral requirement: 'Requires settings scope' (an authorization detail). It also clarifies what the tool shows (whether enabled and configuration), giving the agent an understanding of the response. It does not describe side effects, but as a 'get' operation, none are expected. The auth scope disclosure adds significant value 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 consists of two concise sentences. The first sentence states the core function, and the second adds output detail and an auth requirement. There is no filler or redundancy; every sentence earns its place. Information is front-loaded with the action immediately.

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

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

The tool is simple (one parameter, no output schema), and the description adequately covers the key aspects: what it does, what it returns conceptually, and an auth requirement. It does not describe the exact structure of the configuration, but for a getter with no output schema, this is acceptable. The description is complete enough for an agent to use correctly without further clarification.

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

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

The schema already provides 100% coverage for the single parameter accountId, describing it as 'The Google account ID, alias, or email.' The description adds no extra detail about the parameter, but given the full schema coverage, the baseline is 3. The description's mention of 'for an account' aligns with the parameter but does not enhance meaning beyond the schema.

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

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

The description clearly states the specific action ('Get the vacation auto-reply settings') and the resource ('for an account'). It also elaborates on the output ('Shows whether vacation responder is enabled and its configuration'), which distinguishes it from sibling tools like gmail_set_vacation. The verb 'Get' and explicit mention of vacation settings make the purpose unambiguous.

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

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

The description clearly indicates this tool is for retrieving vacation auto-reply settings, which implies when it should be used. It does not explicitly mention alternatives or exclusions, but the read-only nature and specific resource are enough to guide selection. The omission of a direct reference to gmail_set_vacation is a minor gap, but the context alone is sufficient.

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

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

With no annotations provided, the description carries the full burden. It discloses that the operation is read-only (requires readonly scope) and specifies exact output fields, which is transparent for a listing tool. It does not cover edge cases, but the core 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?

Two sentences deliver purpose, output, and requirement with no redundant words. The description is front-loaded and efficient.

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

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

For a simple list operation with 2 fully-described parameters and no output schema, the description covers purpose, return values, and permission requirements. It is slightly incomplete in not explicitly stating that it does not return binary content, but this is implied by the listed return fields.

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 parameters fully described in the input schema. The description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb 'List', resource 'attachments in a Gmail message', and enumerates the returned metadata (IDs, filenames, MIME types, sizes). This distinguishes it from sibling tools like gmail_get_attachment or gmail_bulk_save_attachments.

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

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

The description implies the usage context (listing attachment metadata) and notes the readonly scope requirement, but it does not explicitly mention alternatives or when-not-to-use conditions, such as when needing to download attachment content.

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 bears the full burden. It discloses the permission requirement 'Requires settings scope' and implies a read-only operation via 'List all'. However, it does not describe response format, pagination, or error behavior, leaving some 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?

The description is three short sentences, front-loaded with the purpose. The second sentence explaining filters is optional but adds domain context without waste. It is appropriately concise.

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

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

Given the simple one-parameter tool and no output schema, the description covers the core action and a key prerequisite. However, it doesn't mention what the response contains (e.g., filter IDs, criteria) or whether results are paginated, so some completeness gap remains.

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

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

The schema already fully describes the accountId parameter, including accepted formats ('Google account ID, alias, or email'). The description adds no additional parameter-level detail, so the high schema coverage carries the semantics.

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

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

The description states 'List all Gmail filters for an account' with a specific verb and resource. It distinguishes from sibling create/delete filter tools by being the list operation, and adds domain context about filters.

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

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

The description does not explicitly state when to use this tool vs alternatives like gmail_list_labels or gmail_create_filter. It mentions the required 'settings scope' which is a precondition, but uses are implied by the tool name and purpose.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It adds useful context: requires full scope and includes system labels. However, it does not explicitly state that the operation is read-only or describe return format/pagination, leaving some uncertainty for an agent.

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

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

The description is a single, front-loaded sentence that conveys the core purpose, the label types included, and the auth requirement. No wasted words, excellent structure.

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

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

For a simple list operation with one parameter and no output schema, the description plus schema covers the essentials: what it does, the auth requirement, and the parameter. It could mention the return shape, but that is not critical for such a straightforward tool.

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

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

The schema description covers the single parameter (accountId) fully, so the baseline is 3. The description adds no additional parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: 'List all Gmail labels' with a specific verb and resource. It explicitly distinguishes system labels from custom user labels, making it unambiguous and distinct from sibling label management tools.

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

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

The description provides clear context that this is for listing all labels and notes the 'full scope' prerequisite. It does not explicitly mention alternatives, but no alternative list-labels tool exists, so the guidance is adequate. Still, it could be more explicit about using this tool to retrieve label IDs for subsequent operations.

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

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

With no annotations, the description carries the burden of disclosure. It states 'Requires full scope' (auth requirement) and clarifies that the operation modifies the UNREAD label, which explains the underlying mechanism. It does not detail return values or edge cases, but for a simple mutation this is adequate.

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

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

Two sentences, with the primary action in the first sentence and the key differentiator in the second. No redundant information, perfectly front-loaded.

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

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

For a tool with three simple parameters, no output schema, and no nested objects, the description covers the essential context: the action, the underlying mechanism, and the required scope. It could mention that other labels are unaffected, but the 'shortcut for modifying the UNREAD label' already implies this.

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

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

The schema already documents all three parameters with 100% coverage, so the description need not add much. It does not provide additional parameter-level detail beyond restating the markAsRead boolean semantics, earning the baseline score of 3.

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

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

Description uses specific verb 'Mark' with resource 'Gmail message' and states the two possible states (read/unread). The phrase 'shortcut for modifying the UNREAD label' distinguishes it from the more general gmail_modify_labels sibling tool, making the purpose crystal clear.

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

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

The 'shortcut' phrasing implies when to use this tool: when you specifically want to toggle read/unread without dealing with full label operations. It provides clear context but does not explicitly name alternatives or state when not to use it, so it falls short of a 5.

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

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

With no annotations provided, the description carries the behavioral transparency burden. It discloses that full scope is required, which is useful. However, it does not disclose potential side effects, what happens when both add and remove are specified, or whether the operation is idempotent. The description is not misleading, but it lacks depth.

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

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

The description is two concise sentences, front-loaded with the core action, and provides an efficient example. No fluff. It fully 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?

The tool is relatively simple with 4 parameters and no output schema. The description covers the main action and scope, but it omits context such as the relationship to batch operations, behavior when no label IDs are provided, or typical use cases. It is adequate but not fully complete for guiding an agent.

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

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

Schema coverage is 100% with each parameter described. The description adds examples (e.g., 'INBOX', 'STARRED') and clarifies the use of label IDs, which reinforces the schema but does not add substantial new meaning. It meets the baseline for high schema coverage.

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

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

The description clearly states the tool's function: adding or removing labels from a Gmail message. It uses a specific verb ('Add or remove') and resource ('labels from a Gmail message'). While it doesn't explicitly distinguish itself from sibling gmail_batch_modify_labels, the singular 'a Gmail message' implies single-message scope, which differentiates it from the batch variant.

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

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

The description implies usage for modifying labels on a single message and tells the agent to use label IDs, but it does not explicitly state when to use this tool instead of alternatives like gmail_batch_modify_labels or gmail_archive. The scope requirement is mentioned, but no clear exclusion criteria or alternative tool references are provided.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses the two main behaviors (creating a draft and optionally sending) and the required OAuth scope. It does not mention the confirm gate for sending, but that is covered in 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 two sentences with no redundancy. It front-loads the primary purpose, then adds the draft/send behavior and auth requirement. Every word earns its place.

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

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

Given 12 parameters, no output schema, and no annotations, the description effectively communicates the core action, auth prerequisites, and draft-vs-send options. The schema handles parameter details, so the description is sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema's fields; it only states the overall function and scope requirement.

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: 'Reply to an existing email thread' clearly states the action. It further clarifies that it creates a draft and optionally sends, distinguishing it from generic draft creation or send-only 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 phrase 'Reply to an existing email thread' clearly indicates the intended use case versus creating new drafts. However, it does not explicitly name alternative sibling tools or provide exclusion criteria, so it falls just short of a 5.

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

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

With no annotations, the description bears the full burden of disclosing behavior. It does not state whether the tool is read-only, what the response contains (list of message IDs vs. full messages), whether authentication is required, or any pagination/rate-limit behavior. The examples of Gmail syntax provide some operational context, but significant behavioral traits remain undisclosed.

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

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

The description is a single, front-loaded sentence that immediately states the action and resource. It uses parentheses for examples, keeping the main clause clean. Every word earns its place, and there is no redundancy or filler.

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

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

There is no output schema, so the description should clarify what the tool returns. It does not mention whether results are full message objects, summaries, or just IDs. It also omits any prerequisites (e.g., account must be authenticated) and does not reference pagination behavior despite the pageToken parameter. This leaves the agent under-informed for a search tool.

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

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

Schema coverage is 100%: all four parameters (query, accountId, pageToken, maxResults) have descriptions. The description adds value by giving example query values, which helps understand the 'query' parameter. However, it does not elaborate on other parameters beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Search for messages in Gmail using Gmail search syntax'. It provides concrete examples ('from:user@example.com', 'subject:hello', 'is:unread') that illustrate the query format. This differentiates it from sibling tools like gmail_get_message (fetch a specific message) and gmail_list_labels (list labels).

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

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

The description implies usage by giving search syntax examples but does not explicitly state when to choose this tool over alternatives like gmail_get_message or gmail_get_messages_batch. It lacks exclusions or explicit situational guidance, so it falls into the 'implied usage' category rather than clear context with alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly warns 'This will actually send the email' and emphasizes the confirm safety gate, which is crucial for an irreversible action. It also mentions the required OAuth scope. It does not describe post-send behavior, but the key risks are covered.

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

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

The description is two sentences long, front-loaded with the core purpose, and includes a critical safety warning. Every sentence provides value, and there is no fluff or repetition.

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

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

For a simple send action, the description covers the essential context: the irreversible nature, the confirmation requirement, and the required scope. It does not explain return values, but no output schema is present and the action's outcome is obvious. Sibling tools provide enough surrounding context to distinguish this operation.

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

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

Schema coverage is 100% and each parameter has a clear description in the schema. The tool description repeats the confirm requirement but does not add additional meaning beyond what the schema already provides. Baseline 3 applies because the schema 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 'Send a draft email' with a specific verb and resource, clearly distinguishing it from sibling tools like gmail_create_draft, gmail_update_draft, and gmail_delete_draft. The action is unambiguous and leaves no doubt about what the tool does.

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

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

The description makes clear that this tool is for sending an already-created draft, which is implied by the context. It does not explicitly name alternatives or exclusions, but the contrast with other draft-related tools is evident. The safety warning about confirm being required is an operational guideline.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses that enabling requires confirmation and that a settings scope is needed, which are important behavioral traits. However, it does not mention other behaviors such as idempotency, interaction with existing settings, or what happens on disable.

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 only two sentences, front-loaded with the main purpose ('Configure the vacation auto-reply settings') followed by crucial prerequisites. Every sentence earns its place with no redundant 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 tool with 10 parameters and no output schema, the description is brief but the schema covers parameter details. It provides key requirements (confirmation, scope) but lacks broader context such as the effect of disabling, whether partial updates are allowed, or how the settings integrate with Gmail. The absence of an output schema is not an issue, but the description could be more 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds minimal parameter context beyond mentioning confirmation, which aligns with the confirm parameter, but it does not explain any parameters in detail. The schema already provides thorough documentation.

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

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

The description clearly states 'Configure the vacation auto-reply settings' and 'Can enable or disable the vacation responder', which specifies the verb and resource. This distinguishes it from the sibling tool gmail_get_vacation, which is for reading the current settings.

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