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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does so excellently. It reveals that token validity is proven by live refresh, that 'null' means Google was unreachable, that a dead account includes a 'status' and 'detail' field, and that the token file existing is not sufficient. This is meaningful behavioral context beyond the tool name.

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

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

The description is compact and front-loaded: the first sentence states exactly what the tool lists, and the second sentence adds crucial interpretation details without redundancy. Every sentence contributes 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 zero-parameter tool with no output schema, the description is complete. It explains the meaning of the key output field ('authorized'), edge-case behavior when Google is unreachable, and the presence of status/detail fields for dead accounts. An agent has enough information to call the tool and interpret its result 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 has zero parameters, so there is nothing for the description to clarify. Baseline for zero-parameter tools is 4, and the description correctly focuses on output semantics instead, which is the only relevant aspect for invocation.

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 'List' and clearly identifies the resource: configured Google accounts and the working state of each token. It also adds the key detail that 'authorized' status is verified by refreshing the token, which distinguishes this tool's purpose from merely enumerating account names.

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 tool's purpose clear: use it to check configured accounts and token validity. It does not explicitly name alternatives or state when not to use it, but among the sibling tools none overlap with this account-listing functionality, so the absence of explicit exclusions is acceptable.

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 explains the start/end format nuance but omits other behavioral aspects like permissions, error conditions, side effects of attendee list or send_updates, and return value 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 extremely concise: two sentences that convey the essential action and a critical formatting note. Every word 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?

Given the complexity of 11 parameters, no output schema, and no annotations, the description is incomplete. It covers the datetime nuance but nothing about return values, error handling, or timezone 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 description coverage is 0%, yet the description only adds meaning for two parameters (start, end) out of eleven. The remaining parameters (account, summary, calendar_id, etc.) are left entirely to schema property names.

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 an event.' It also adds a useful detail about datetime format and all-day event creation, which is specific and helpful.

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 guidance on when to use this tool versus alternatives (e.g., calendar_event_update), nor does it mention prerequisites or conditions for use.

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 should disclose behavioral traits. It only states the action but omits details like permanence, side effects (e.g., notifications), or required permissions.

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

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

Extremely concise (3 words) but under-specified. Conciseness should balance with informativeness; this is insufficient.

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 4 parameters, no output schema, and no annotations, the description is vastly incomplete. It fails to explain required vs. optional parameters, return behavior, or error cases.

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

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

Schema has 0% description coverage, and the description provides no explanation of parameters. It does not add meaning beyond the parameter names and types.

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

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

Description is a clear verb+resource 'Delete an event', but does not distinguish from sibling tools like calendar_event_update or calendar_event_get.

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

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

No guidance on when to use this tool versus alternatives like calendar_event_update or calendar_event_trash. No context on prerequisites or common scenarios.

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 exist. The description only states 'Fetch', which implies a read, but no details on failure modes, permissions, or side effects are 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?

Extremely brief (3 words) but severely under-specified for a tool with three parameters. Lacks critical information needed for proper use.

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, the description should at minimum explain input requirements and output behavior. It omits both, leaving the agent without enough context for correct invocation.

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

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

Schema description coverage is 0% and the description does not explain any parameter meanings. The schema lists three parameters (account, event_id, calendar_id) but the description adds no semantic context.

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

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

The description 'Fetch one event' clearly indicates a read operation for a single event. While brief, it distinguishes from sibling tools like calendar_events_list and CRUD operations.

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

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

No guidance provided on when to use this tool versus alternatives such as calendar_events_list for multiple events. No exclusions or prerequisites mentioned.

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 exist, so the description carries full burden. It only provides a format tip for time_min/time_max (RFC3339) but omits other behaviors like pagination, default ordering, or authentication 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 very short (one sentence + example), which is concise but under-specifies the tool. It front-loads the action but lacks necessary details for effective use.

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

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

With 7 parameters and no output schema, the description is insufficient. It should explain each parameter's purpose, default behavior, and response structure to enable correct invocation.

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

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

Schema coverage is 0%. The description only adds meaning for time_min/time_max (format example). Other parameters (account, calendar_id, query, max_results, single_events) remain undocumented, offering minimal additional value.

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 says 'List events', which clearly identifies the action and resource. Given the tool name 'calendar_events_list', it distinguishes from sibling tools like 'calendar_event_get' (single event) or 'calendar_event_create'.

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

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

No guidance on when to use this tool vs alternatives (e.g., calendar_event_get, calendar_search). The description only lists the tool's basic function without context for decision-making.

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 only mentions partial update behavior, but does not disclose potential side effects (e.g., notification to attendees via send_updates parameter), required permissions, error handling, or confirmation of changes. This is minimal disclosure 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 short sentence that is immediately understandable. It is front-loaded and wastes no words. However, it could be slightly expanded with a note about required parameters or common usage without losing 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?

Given 11 parameters, no output schema, and no annotations, the description is incomplete. It does not mention required parameters (account, event_id), the default for calendar_id ('primary'), or how to format date strings. The send_updates parameter with three options is not addressed. The description lacks sufficient detail for an agent to confidently invoke the tool.

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

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

Schema description coverage is 0%, so the description is expected to add meaning. It only says 'only the fields you pass are changed' which is a general behavior, but does not explain any of the 11 parameters (e.g., date format for start/end, the meaning of attendees, or the send_updates enum). The description adds very little value beyond what the parameter names and types suggest.

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 clearly states 'Patch an existing event' which is a specific verb+resource, and 'only the fields you pass are changed' explains the scope of the update. This distinguishes it from sibling tools like calendar_event_create (create) and calendar_event_delete (delete).

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

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

The description implies use for updating an existing event, but does not explicitly state when to use versus alternatives or when not to use. It provides no exclusions or comparisons with other tools, relying on the tool name and context from 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 provided, the description must fully disclose behavioral traits. It only states a simple read action but omits details like pagination, return format, authentication requirements, or any side effects.

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

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

The description is a single, concise sentence with no extraneous information. It 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?

Given the lack of output schema and annotations, the description is incomplete. It fails to describe the return format, possible errors, or parameter semantics, leaving significant gaps for 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?

The schema has 0% description coverage, and the description does not explain the 'account' parameter (e.g., format, permissible values). The agent has no semantic clues beyond the parameter name.

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 all calendars the account can access, using a specific verb and resource. It effectively distinguishes from sibling tools like accounts_list (lists accounts) and event-specific 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 no guidance on when to use this tool over alternatives, no exclusions, and no context about prerequisites. The agent must infer usage solely from the name and description.

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

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

No annotations are provided, so the description carries the full burden. It only discloses the export MIME type behavior for certain file types but omits other important behavioral traits like overwrite behavior, authentication requirements, rate limits, or what happens when saving to a path. The disclosure is 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 with no waste. The first sentence states the core purpose, and the second adds essential nuance. Structurally efficient, though could be slightly more organized with parameter hints.

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 4 parameters, no output schema, and no annotations. The description is incomplete: it does not explain all parameters, constraints (e.g., file size limits), or what the tool returns (e.g., whether it writes to a file or returns binary). The export note is helpful but insufficient.

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

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

Schema description coverage is 0%, meaning parameters are not described in the schema. The description adds meaning for `export_mime_type` with examples, but does not explain `account`, `file_id`, or `save_to`. With 4 parameters and zero schema descriptions, the description should compensate more fully.

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 'Download a file' with a specific verb and resource. It adds crucial detail about exporting Google Docs/Sheets/Slides with `export_mime_type`, distinguishing it from sibling tools like `drive_file_get` which might only retrieve metadata.

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 downloading files and hints at when to use `export_mime_type`, but it does not explicitly state when to use this tool versus others (e.g., `drive_file_get` for metadata) or provide exclusions. Usage context is clear but not comprehensive.

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

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

With no annotations, the description does not disclose safety, read-only nature, error behavior, or authentication needs. While 'get' implies a safe read operation, it does not explicitly state that no side effects occur.

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?

One short sentence efficiently communicates the core purpose. However, the extreme brevity sacrifices valuable information that could be added without losing conciseness (e.g., a brief note on expected input format).

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 annotations, no output schema, and sparse parameter info, the description fails to provide sufficient context for correct usage. It does not explain what 'full metadata' includes, nor how to interpret the response.

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

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

Schema coverage is 0%, meaning no parameter descriptions in the schema. The description adds no explanation for the two required parameters (account, file_id), leaving their meaning and format entirely opaque.

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 'Get a file's full metadata' clearly states the action (get) and resource (file metadata), distinguishing it from sibling tools that download, move, or delete files. However, 'full metadata' is slightly vague and could benefit from specifying typical fields.

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

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

No guidance on when to use this tool versus alternatives like drive_search or drive_file_download. The description does not mention prerequisites, such as requiring the file ID, or contrast with other retrieval methods.

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 behavioral burden. It discloses the mutation, the ownership prerequisite, the temporary nature of the access, and the security requirement to always revoke. It could mention side effects on existing link permissions, but the provided safety guidance is substantial.

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

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

The description is compact and front-loaded with the core purpose. The flow and warnings are concise, each sentence adds value, and the structure moves naturally from purpose to usage to caution.

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 toggle with no output schema, the description covers the key flow, the returned direct_download_url, and the necessary revocation step. The main missing piece is the 'role' parameter and error/edge-case behavior, but the core context needed to call the tool correctly 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 0%, so the description must compensate for the undocumented parameters. It explains the 'enabled' toggle and implies 'file_id' and 'account', but it does not explain the 'role' parameter, which has an enum and default. This leaves a meaningful gap for the agent.

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

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

The description uses a specific verb and resource: 'Toggle anyone with the link access on a file the account owns.' This precisely identifies the operation and differentiates it from sharing tools like drive_file_share by focusing on the link-access toggle mechanism.

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 a clear use case: enabling temporary link access for zero-bandwidth server-side fetches, then revoking immediately. It does not explicitly name alternatives or state when not to use the tool, but it gives a strong contextual trigger and a concrete workflow.

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 burden for behavioral disclosure. It only states the basic action, omitting important details such as whether permissions are affected, if multiple files can be moved, if the operation is reversible, or any side effects like automatic removal of old parents (though a parameter hints at this).

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 extremely concise at one sentence, but at the expense of completeness. While there is no wasted text, the brevity fails to convey necessary details given the tool's complexity (4 parameters, no annotations). It is efficiently written but under-informative.

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 4 parameters, no annotations, and no output schema, the description is severely lacking. It provides no information on return values, required permissions, error scenarios, or parameter dependencies. The description is insufficient for an agent to use the tool reliably.

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

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

The schema has 0% description coverage, and the tool's description adds no information about any parameter. Parameters like 'account', 'file_id', 'new_parent_id', and 'remove_old_parents' are not explained, leaving the agent without essential context to set them 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 action ('Move') and resource ('file'), and the target ('new folder'). It distinguishes from sibling tools like rename, share, or trash. However, it lacks specificity about scope (e.g., within account) and the meaning of 'folder' in the context of drives.

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 move versus alternative tools (e.g., rename, share). There is no mention of prerequisites, limitations, or when not to use the tool. The description is purely functional without contextual guidance.

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

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

No annotations exist, and the description provides zero behavioral details. It does not disclose side effects, permissions, or whether renaming affects file location or metadata.

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 technically concise but fails to convey necessary information. For a tool with multiple parameters and siblings, significant under-specification outweighs brevity.

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, no annotations, and a complex sibling set, the description is entirely insufficient. It omits return values, error conditions, and practical usage context.

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?

Input schema has 3 required parameters with 0% description coverage. The description adds no meaning to account, file_id, or new_name, leaving agents without crucial formatting or context hints.

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

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

Description 'Rename a file.' is a tautology that adds no value beyond the tool name. It provides a verb and resource but is minimal and does not distinguish from siblings like drive_file_move or drive_file_share.

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

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

No guidance on when to use this tool compared to alternatives. Given siblings like drive_file_move or drive_file_trash, agents need context to decide which to invoke.

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 exist, and the description is too brief to disclose behavioral traits such as sharing immediacy, notification behavior, error handling, or permission requirements. The schema hints at parameters like 'send_notification' and 'message', but the description does not explain them.

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 extremely concise (6 words), but this is an under-specification rather than efficient conciseness. It lacks structure and fails to convey necessary details.

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

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

Given the tool's complexity (6 parameters, no output schema, no annotations), the description is grossly incomplete. It does not cover return values, side effects, prerequisites, or parameter behavior, leaving the agent with insufficient information.

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

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

Schema description coverage is 0%, yet the description adds almost no value for any of the 6 parameters. Terms like 'account', 'file_id', 'role', 'send_notification', and 'message' remain unexplained, leaving the agent without crucial semantic context.

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

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

The description clearly states the action 'Share', the resource 'a file', and the method 'by email'. It is specific and gives a basic understanding of the tool's purpose, though it does not explicitly distinguish it from sibling tools.

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

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

No usage guidelines are provided. The description does not indicate when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it.

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

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

With no annotations provided, the description bears full responsibility for behavioral disclosure. It only states 'reversible', omitting important details such as permission requirements, effects on shared files, or whether the operation is idempotent.

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

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

The description is a single, concise sentence with no extraneous information. However, given the lack of other context, it may be too brief, but it remains well-structured for its length.

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 tool with two required parameters and no output schema or annotations, the description is incomplete. It lacks parameter documentation and usage instructions, which are necessary for an agent to correctly invoke the tool.

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

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

The input schema has 0% description coverage for parameters, and the description does not explain the meaning or format of 'account' and 'file_id' beyond their names. This provides no added value for parameter understanding.

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

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

The description clearly states the action ('Move a file to trash') and the resource ('file'), and explicitly notes reversibility, which distinguishes it from permanent deletion. 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?

No guidance is provided on when to use this tool versus alternatives (e.g., drive_file_move, gmail_message_trash). No when-not-to-use or context information 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?

With no annotations, the description carries the full behavioral burden and delivers: mutation is implied and its in-place semantics are disclosed (ID/link/sharing preserved), plus revision-history behavior for both Google-native formats and binary files, the 30-day/100-revision drop policy, and the keep_revision_forever pin limit of 200. This is exactly the kind of side-effect context an agent needs for a destructive-looking update.

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

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

Four sentences, zero filler, and primary purpose front-loaded in the first clause. Each subsequent sentence earns its place: sibling disambiguation, conversion semantics, and retention-policy caveat. The length is justified by the density of non-obvious behavioral information.

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

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

For a mutation tool with 7 parameters, no annotations, and no output schema, this description covers the highest-value context: in-place semantics, the upload alternative, flag behavior, and data-retention caveats. The only real gaps are the lack of a note about the return value/response shape and error conditions (e.g., what happens if file_id doesn't exist or permissions are insufficient). These are minor against the strong coverage of action, selection criteria, and side effects.

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

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

Schema description coverage is 0%, so the description must compensate. It richly explains the two most confusing flags — convert_to_google_doc (revises native Google formats from Office files) and keep_revision_forever (pins revisions, capped at 200) — which are the parameters whose titles alone would mislead an agent. The remaining params (account, file_id, local_path, name, mime_type) are left to their schema titles, which are mostly self-evident, though name and mime_type could use a hint about whether they are ignored during content updates.

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

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

The description opens with a specific verb+resource pair: 'Replace an existing file's contents in place.' It then states concrete identity guarantees (keeps ID, link, sharing) and explicitly distinguishes itself from the sibling drive_file_upload by explaining the upload-alone behavior (creates a second file, does not version). An agent can tell this tool apart from its closest sibling without opening either schema.

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

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

Gives an explicit selection rule: 'Use this rather than drive_file_upload to revise something already in Drive,' backed by the reason why uploading again is wrong for revisions. It also clarifies when convert_to_google_doc=True is appropriate (revising native Docs/Sheets/Slides from local Office files). This is direct, unambiguous routing guidance.

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

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

No annotations provided, so description carries full burden. It discloses upload action and conversion, but misses critical behavioral traits: permissions needed, overwrite behavior, file size limits, error states, or what happens to the uploaded file. 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?

Two sentences, no fluff, directly states purpose and key feature. Well front-loaded. Efficient use of characters.

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 6 parameters, no output schema, and no annotations, the description is too brief. It doesn't mention return values, prerequisites, or error handling. Leaves significant gaps for an agent to correctly invoke the tool.

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

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

Schema description coverage is 0%, yet description only elaborates on convert_to_google_doc. The 5 other parameters (account, local_path, name, parent_folder_id, mime_type) are left unexplained. Fails to compensate for the schema's lack of descriptions.

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

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

The description clearly states it uploads a local file to Drive, with a specific verb and resource. It distinguishes from sibling tools (e.g., download, move) by being the only upload tool. The conversion feature adds specificity.

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 explicit guidance on when to use this tool vs alternatives. It mentions a conversion option but doesn't specify prerequisites or contexts. Implicitly it's for uploading files, but no when-not-to or alternative recommendations.

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, and the description lacks any behavioral details such as side effects, permissions required, or return value. 'Create a new folder' gives no insight into what happens upon creation or potential issues.

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 extremely concise but at the expense of completeness. It is under-specified, failing to provide essential details for a 3-parameter tool. Every sentence should earn its place; here one sentence is insufficient.

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 (3 parameters, no output schema, no annotations), the description is severely incomplete. It does not clarify the role of 'account', whether 'parent_folder_id' is needed for nesting, or what the operation returns.

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

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

Schema description coverage is 0%, so the description must clarify parameter meanings. It does not explain any of the three parameters (account, name, parent_folder_id), leaving the agent without necessary context.

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

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

The description 'Create a new folder' clearly states the action (create) and the resource (folder), which is specific and unambiguous. However, it does not differentiate from any sibling tools, though no direct folder siblings exist in the list.

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

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

No guidance on when to use this tool versus alternatives. The sibling list includes other drive operations, but no mention of conditions or exclusions is provided.

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

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

The description indicates it is a non-destructive search operation, but it does not mention pagination, rate limits, or the fact that it only searches the specified account's files. Without annotations, more clarity on read-only behavior and scope would be beneficial.

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 short and front-loaded with the action, but the inclusion of a URL and multiple examples makes it slightly less efficient. It could be more compact while retaining essential information.

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

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

Given five parameters and no output schema, the description is incomplete. It lacks explanation of the account parameter, return format, and default behavior details, which are necessary for effective use.

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

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

With 0% schema description coverage, the description only addresses the 'query' parameter with examples. The other four parameters (account, max_results, order_by, include_trashed) are not explained, leaving gaps for the agent.

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

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

The description starts with 'List/search files,' which clearly indicates the action and resource. It provides specific examples of query syntax, distinguishing it from sibling tools like drive_file_get or drive_file_download that operate on individual 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 implies usage for file listing/searching but does not explicitly state when to use this tool versus alternatives (e.g., when to use drive_file_get for a specific file). No exclusions or when-not-to-use guidance is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core action ('download') but omits details such as permissions required, file overwrite behavior, size limits, or error handling. The description is minimal but not misleading; a score of 3 reflects adequate transparency for a simple download 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 concise, consisting of two sentences with no wasted words. It front-loads the primary action and quickly provides a key prerequisite. However, it could be slightly expanded (e.g., parameter details) without losing conciseness; the current length is appropriate but lacks some completeness.

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 is a simple download with no output schema, the description provides the essential context: what it does and how to get the `attachment_id`. However, it omits details about the `save_to` path (absolute vs relative, directory existence) and any potential error scenarios. It is marginally adequate for a basic tool.

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

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

Schema description coverage is 0%, so the description must compensate. It only explains the `attachment_id` parameter (how to obtain it) and does not describe `account`, `message_id`, or `save_to`. The description adds minimal meaning beyond the schema, leaving users unclear about the purpose or constraints of three required parameters.

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

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

The description clearly states the tool's action: 'Download one attachment to a local path.' It identifies the specific resource (attachment) and distinguishes it from sibling tools like gmail_message_get (which retrieves message payloads) or gmail_send. The mention of 'attachment_id' and how to obtain it further solidifies the 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 provides a prerequisite: 'Get `attachment_id` from the message payload parts (gmail_message_get with format=full).' However, it does not explicitly state when to use this tool versus alternatives (e.g., when not to use it) or provide contrasts with other tools. The context is helpful but insufficient for comprehensive usage 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 transparency burden and does so thoroughly. It discloses server-side reply quoting, derived In-Reply-To/References headers, multipart/alternative HTML generation, attachment path semantics, and MIME type guessing—all non-obvious behaviors beyond the basic 'create draft' action.

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 long but justified for a 10-parameter tool with many behavioral quirks. Every sentence carries real guidance: body formatting, reply quoting, HTML mode, attachment handling. It is organized into clear paragraphs and front-loads the core purpose and return 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 complex tool with no output schema and no annotations, the description is remarkably complete. It covers the return object, subtle reply behavior, body formatting rules, attachment constraints, and HTML option. The only notable gap is the phantom in_reply_to_message_id reference, but overall the agent has enough context to use 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 0%, so the description must compensate. It does a strong job for body, html, thread_id, quote_history, and attachments, explaining formats and special behavior. However, it references in_reply_to_message_id, which is not present in the input schema, and it does not explain the clear-by-name to/cc/bcc/subject parameters.

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 draft.' It also specifies the return shape ({id, message: {...}}), which distinguishes draft creation from sending or updating drafts.

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 reply scenario is explicitly addressed: 'Replies: pass thread_id and nothing else,' and there is clear guidance on when to set html=true. However, it does not explicitly contrast this tool with siblings like gmail_draft_send or gmail_send, leaving some selection inference to the agent.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions 'permanently delete', implying irreversibility, but lacks details on permissions required, error handling (e.g., if draft does not exist), or side effects. The description is too minimal to adequately inform 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, concise sentence with no redundant words. It is appropriately front-loaded 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?

For a delete tool with two parameters and no output schema, the description is incomplete. It fails to explain return values, error conditions, or idempotency. Parameter semantics are entirely absent, leaving the agent with insufficient context.

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 0% description coverage, and the description provides no information about the two required parameters (account and draft_id). An agent has no guidance on what values to supply or how they are used.

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: 'Permanently delete a draft'. It uniquely identifies the resource (draft) and verb (delete), and distinguishes it from sibling tools like gmail_draft_create or gmail_draft_update. The parenthetical adds context about why this tool exists.

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 explicit guidance on when to use this tool versus alternatives like gmail_draft_send or gmail_draft_create. The parenthetical hints at a special use case but does not clearly specify scenarios or exclusions.

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

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

With no annotations, the description carries full burden but only states the action. It does not disclose what happens to the draft after sending (e.g., it becomes a sent message and the draft is removed), nor any authentication or rate limit considerations.

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

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

The description is very concise (one short sentence), but it sacrifices necessary detail. It is front-loaded with the core action, yet would benefit from additional context to be truly helpful.

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 (two required string params, no output schema), the description should explain the effect (e.g., draft is sent and becomes a sent message) and distinguish from similar siblings like gmail_send. It fails to provide a complete picture.

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

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

Schema description coverage is 0% and the description does not explain the parameters 'account' and 'draft_id'. Their semantics are left entirely to inference from the names, which is insufficient for an agent to correctly invoke the tool.

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 'Send an existing draft' clearly states the verb (send) and the resource (existing draft), differentiating it from sibling tools like gmail_draft_create or gmail_draft_delete. However, it could be more specific by noting that it sends a draft that has been created previously.

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

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

No guidance is provided on when to use this tool versus alternatives like gmail_send or gmail_draft_update. There is no mention of prerequisites or exclusions, leaving the agent to infer usage context.

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

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

No annotations are provided, so the description must convey behavior. It only states 'List drafts' without explaining output format, pagination, rate limits, or any side effects. This is minimal for a read 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?

Extremely concise with two sentences. Front-loaded with the primary action. No extraneous information.

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

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

Given three parameters, one required, and no output schema, the description fails to provide enough context for the agent to correctly invoke the tool. Missing details on return structure, pagination behavior, and account 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 0%, so the description must compensate. It adds meaning only for 'query' by mentioning Gmail search syntax. 'account' and 'max_results' receive no explanation, leaving the agent to infer their roles.

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 'List drafts' with a specific verb and resource. It is distinct from siblings like gmail_search (which targets messages) and other draft operations. The addition of query syntax reference adds specificity.

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

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

No guidance on when to use this tool versus alternatives like gmail_search for messages or gmail_draft_create. The description does not mention when not to use it or prerequisites.

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 delivers richly: it discloses the overwrite side-effect, the detachment behavior ('an update without it detaches the draft'), the multipart/alternative MIME conversion with Gmail-composer-style HTML, Gmail-native list rendering, and the application/octet-stream MIME fallback for attachments. This exceeds what annotations would typically convey.

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?

Four front-loaded paragraphs, each earning its place: a one-sentence purpose statement, then dense but relevant guidance on thread_id semantics, body format with explicit constraints, and attachment path semantics. There is no filler, repetition, or boilerplate.

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 tool with zero annotations, zero schema descriptions, and no output schema, this is close to complete: purpose, threading side-effects, body formatting rules, and attachment semantics are all covered in depth. Minor gaps remain — quote_history's meaning is never tied to the thread_id re-quoting behavior, and the success/return value is unspecified.

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

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

Schema description coverage is 0%, and the description compensates for the four hardest parameters: thread_id (thread attachment plus re-quoting of history), body (plain-text format rules, blank-line paragraphs, bullet/numbering syntax, no hard-wrapping), html (reserved for already-HTML bodies), and attachments (server-local paths with MIME guessing). However, the remaining seven parameters — including quote_history, which has a non-obvious default of true — receive no semantic explanation, though most are self-evident from their names.

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?

Opens with a specific verb+resource combination: 'Overwrite an existing draft's contents.' This unambiguously distinguishes it from sibling draft tools — gmail_draft_create creates, gmail_draft_send sends, gmail_draft_delete removes — and the word 'existing' marks the scope as mutation of a previously created draft.

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 strong conditional guidance for parameters ('Pass thread_id when the draft is a reply', 'Set html=true only for a body that is already HTML'), but never names an alternative tool or states when not to use this one. The distinction from gmail_draft_create is only implied by the word 'existing' rather than made 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?

Without annotations, the description discloses key behavioral traits: idempotency (existing labels returned as-is) and nesting requirements. This adds value beyond the tool name alone. However, it does not cover permissions, rate limits, or response format.

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 extremely concise with two sentences, no fluff. Every sentence adds value: the first states the primary action, the second adds nested label usage and idempotency. 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 4 parameters, no output schema, and no annotations, the description is incomplete. It does not explain all parameters or their defaults, and does not describe the return value for new labels. The nesting tip and idempotency note are helpful but insufficient for full understanding.

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

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

Schema description coverage is 0%, so the description carries the burden. It only hints at the 'name' parameter format for nesting, but provides no explanation for 'account', 'label_list_visibility', or 'message_list_visibility'. The description adds minimal 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 clearly states 'Create a label', specifying the action and resource. It also provides additional context about nested labels, making the purpose specific and distinguishable from sibling tools like gmail_labels_list.

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 guidance on when to use the tool and how to handle nested labels (create parent first). It also notes idempotency, indicating safe repeated calls. No exclusions or alternatives are provided, but the context 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?

No annotations are provided, so the description carries full burden. It only states 'list all labels' with no disclosure of behavioral traits like read-only nature, auth requirements, 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?

The description is a single short sentence with no wasted words. However, it could include more useful information without sacrificing 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?

Given no output schema, no annotations, and minimal description, the tool is under-documented. Missing information about return values, authentication, and parameter semantics.

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

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

Schema description coverage is 0%. The description does not add any meaning to the 'account' parameter beyond what is in the schema. No explanation of what 'account' refers to (e.g., email address, ID).

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 (list) and the resource (labels) for the account. No sibling tools exist for labels, so no differentiation needed.

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

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

No guidance is provided on when to use this tool versus alternatives. While there are no sibling label tools, the description does not mention any context for usage.

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, description only reveals that format=full includes the body, implying others may not. No disclosure of authentication needs, rate limits, or side effects.

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 redundancy, but extremely brief. Could be expanded without becoming verbose.

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?

No output schema and minimal description leave uncertainty about return values and how to interpret results.

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

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

Schema coverage is 0%; the description only clarifies the 'format' parameter effect. 'account' and 'message_id' are left unexplained.

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 it fetches one message and explains the format parameter's effect. However, it does not distinguish from sibling tools like gmail_thread_get or gmail_search, which also retrieve message data.

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

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

No guidance on when to use this tool versus alternatives. No mention of prerequisites, limitations, or when to avoid.

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

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

Annotations are absent, so the description must fully disclose behavioral traits. It implies mutation (adding/removing labels) but does not mention reversibility, permissions, rate limits, or side effects like UI changes. The example hints at usage but is insufficient.

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 efficiently conveys the core action. It could be restructured to include parameter details, but as is, it is concise and 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?

Given the tool has 4 parameters, no output schema, and no annotations, the description is severely incomplete. It fails to explain how to obtain label IDs, the behavior when both add and remove are specified, error handling, or usage across multiple messages.

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?

With 0% schema description coverage, the description must explain parameter meanings. It only indirectly references 'add_label_ids' and 'remove_label_ids' via the example, but does not clarify their format, source, or relation to Gmail labels. Two required parameters (account, message_id) are completely unexplained.

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 'Add/remove' and the resource 'labels on a message', and provides a concrete example ('mark read by removing UNREAD'). This distinguishes it from sibling tools like gmail_message_trash or gmail_send.

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 explicit guidance on when to use this tool versus alternatives (e.g., gmail_message_trash for deletion, gmail_message_get for reading). It lacks context on prerequisites or decision criteria.

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

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

With no annotations, the description carries the full burden. It discloses reversibility and duration, but omits details like required permissions, thread-level effects, or the behavior if the message is already trashed. This is adequate but not thorough for a mutation action.

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

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

Single sentence with no wasted words. It is front-loaded with the core action and includes a parenthetical qualifier for reversibility. Perfectly 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 no output schema, no annotation coverage, and minimal description, the tool is under-documented. The agent lacks information about return values, error conditions, or handling of edge cases (e.g., message already in trash). Requires significant inference.

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

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

Schema description coverage is 0%, meaning neither the schema nor the description explains the parameters. The description does not mention 'account' or 'message_id', leaving the agent to guess their meaning. This severely undermines correct invocation.

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 a message to Trash') and includes a key behavioral detail (reversible for 30 days). It effectively distinguishes from sibling tools like gmail_message_get (read-only) and gmail_send (send email).

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

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

The description provides no guidance on when to use this tool vs alternatives (e.g., permanent deletion, archiving). It does not mention prerequisites or constraints beyond the 30-day reversibility, leaving the agent to infer appropriate use cases.

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 full burden for behavioral disclosure. It only mentions the query syntax and gives an example, but omits critical details like result limits, pagination, default label scope, or error handling. The agent lacks understanding of what the tool does beyond the basic search action.

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 with an example, making it concise and front-loaded. However, it could be slightly expanded to cover parameter usage without losing brevity.

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 is severely incomplete. It fails to explain the required 'account' parameter, optional filters, or return value structure. The agent lacks sufficient context to use 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 schema description coverage is 0%, meaning the parameter names provide no meaning. The description does not explain any of the five parameters (account, query, max_results, label_ids, include_spam_trash) beyond the query example. The agent cannot infer how to use parameters like 'account' or 'label_ids' from this 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 tool's function: searching messages using Gmail's query syntax. This distinguishes it from sibling tools like 'gmail_message_get' (retrieve a single message) or 'gmail_thread_get' (get a thread).

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

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

The description implies when to use the tool (when searching with Gmail syntax), but it does not provide explicit guidance on when not to use it or mention alternatives. For example, it does not contrast with 'gmail_message_get' for retrieving individual messages.

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 and handles it well: it discloses that the server reads and quotes thread history, derives In-Reply-To/References headers, converts plain text to Gmail-style HTML, and treats attachments as local server paths with MIME guessing. These are critical non-obvious behaviors that structured data cannot convey.

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

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

Three compact labeled sections deliver all the non-obvious usage rules without digression. The primary purpose is front-loaded, and every sentence carries actionable information an agent needs before calling.

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 thorough for send-specific pitfalls: quote duplication, line wrapping, HTML conversion, and attachment sources. However, with no output schema, it is silent about what the call returns (e.g., message ID or success confirmation), which is a minor gap for follow-up use.

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

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

The schema has 0% description coverage, and the description compensates for the hardest parameters: body formatting rules, html behavior, thread_id/reply interplay, quote_history, in_reply_to_message_id override, and attachment path semantics. Naturally evident parameters like to, cc, bcc, subject, and account receive no added detail, but their names are self-explanatory.

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 opening line, 'Send an email immediately from the given account,' names the action, resource, and the immediate-send distinction that separates it from draft-oriented siblings like gmail_draft_send. The scope is unambiguous without needing to inspect parameters.

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 situational guidance: for replies, pass thread_id and nothing else; use quote_history=false to suppress quoting; set html=true only for pre-HTML bodies. It does not explicitly name when to choose a draft tool instead, though 'immediately' implies that boundary.

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 provided, so the description carries full burden. It only states it fetches all messages but does not disclose pagination, formatting, authentication requirements, rate limits, or return structure. Minimal behavioral insight.

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?

Extremely concise single sentence, but it is too minimal. While it has no fluff, it lacks necessary detail to be informative. Could benefit from more context without sacrificing 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?

No output schema, so description should explain return values. It says 'all messages' but is vague on structure (e.g., includes subject, body, attachments). Incomplete for a fetch tool with no other documentation.

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

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

Schema description coverage is 0%, and the description does not explain the two parameters (account and thread_id). No format hints or examples provided. The description adds no 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 'Fetch a whole thread (all messages)' clearly states the verb (Fetch), resource (thread), and scope (all messages). It distinguishes itself from siblings like gmail_message_get (single message) and gmail_search (search 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?

No guidance on when to use this tool versus alternatives (e.g., gmail_message_get for a single message). No context about prerequisites or scenarios. The description is too brief to provide usage 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 provided, so description carries burden. It discloses the mutation (mark completed) but omits details on side effects, permissions, or reversibility.

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

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

Single sentence, instantly clear, no waste.

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

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

No output schema, no annotations, and parameter semantics are absent. The description covers only the core action, leaving many operational details unspecified.

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 has 3 parameters with 0% description coverage. The description adds no meaning to 'account', 'task_id', or 'tasklist_id', leaving the agent without guidance on how to specify them.

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 ('Mark a task completed') and resource ('task'), and distinguishes it as a shortcut for setting status to 'completed', which differentiates it from sibling tools like task_update.

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 (as a shortcut for completion) but does not explicitly provide context on when not to use or compare with alternatives like task_update.

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?

Discloses due date truncation and subtask/parent ordering, but with no annotations, it omits auth needs, error handling, or side effects like tasklist modification.

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?

Front-loaded with 'Create a task.' Three sentences with no fluff. Each 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?

With 7 parameters, no output schema, and no annotations, the description leaves notes and tasklist_id unexplained. It doesn't cover error conditions 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?

Explains due, parent, and previous (3 of 7 parameters), adding format and behavior details. However, notes, tasklist_id, account, and title are not explained beyond the schema, which has 0% 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 states 'Create a task' with a specific verb and resource, and it is distinct from sibling tools like task_update or task_complete.

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 explicit when-to-use or when-not-to-use, but the creation context is implied. Alternatives like task_update for modifications are not mentioned.

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

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

With no annotations, the description must disclose behavioral traits. It only states 'Irreversible', which is important, but omits other key aspects such as permissions required, effects on subtasks, or whether deletion requires ownership. The single trait is insufficient 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 very concise (two sentences) with no redundant words. However, it lacks structure and is too minimal for a 3-parameter tool. It is not well-structured to guide an agent on usage.

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 3 parameters (two required), no output schema, and no annotations, the description is severely incomplete. It fails to explain the role of each parameter, the context of the task (e.g., which task list), or the return value. The agent cannot reliably invoke this 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 schema description coverage is 0%, so the description must compensate. However, it provides no explanation of the three parameters (account, task_id, tasklist_id). The agent cannot infer the format or purpose of account or task_id beyond their names.

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 'Delete a task' clearly states the verb (delete) and resource (a task). It is unambiguous and distinguishes from sibling tools like task_complete (which marks complete) and task_update (which modifies).

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

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

The description mentions 'Irreversible' as a caution, but does not provide explicit guidance on when to use this tool versus alternatives like task_complete or task_update. No conditions or prerequisites are given.

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

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

The description says 'Fetch a single task,' implying a read operation, but does not explicitly state that it is read-only, nor mention any side effects or requirements. With no annotations, the description should disclose more behavioral details.

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

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

The description is very concise (4 words) with no wasted words. However, it is under-specified; a slightly longer description would improve clarity without losing 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?

Given 3 parameters and no output schema, the description is incomplete. It does not explain the return value, parameter constraints, or any context about the task object. The tool's simplicity does not excuse the lack of essential 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 description does not explain the parameters (account, task_id, tasklist_id). With 0% schema description coverage, the description must compensate, but it provides no extra meaning beyond parameter names.

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 'Fetch a single task,' which clearly indicates the verb and resource. It distinguishes from siblings like task_list (list multiple tasks) and task_create. However, it could be more specific about the task context.

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

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

No guidance on when to use this tool versus alternatives like task_list. The description lacks explicit usage context, such as when to fetch a single task vs. listing all tasks.

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 present, and the description fails to disclose behavioral traits such as read-only nature, pagination, or authentication 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 very concise with two clear sentences, but could be slightly more informative without becoming verbose.

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 5 parameters, no output schema, and no annotations, the description is insufficient—it omits output format, pagination, and parameter details beyond tasklist_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?

With 0% schema coverage, the description only mentions tasklist_id and '@default', ignoring crucial parameters like account, show_completed, show_hidden, and max_results.

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 'List tasks in a list' and provides specific details about the '@default' tasklist_id, making the tool's 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?

It tells users to find ids via tasklist_list and explains the '@default' shortcut, but does not specify when to use this tool versus siblings like task_get or task_create.

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 provided. The description does not disclose behavioral traits such as whether it is destructive, requires authentication, or has rate limits. For a creation tool, it only implies mutation without further detail.

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, which is concise but lacks structure. It could benefit from additional detail without sacrificing 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?

Given the simple tool (2 required params, no output schema), the description is incomplete. It does not mention return values, error conditions, or any side effects, leaving gaps for the 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?

The input schema has two parameters (account, title) with 0% description coverage. The tool description adds no meaning beyond the schema, leaving the agent without guidance on parameter 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 clearly states the action 'Create' and the resource 'task list', distinguishing it from sibling tools like tasklist_delete or tasklist_list. However, it lacks specificity about what a task list entails in this context.

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

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

No guidance on when to use this tool versus alternatives like task_create. No context on prerequisites or conditions for creation.

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 full burden. It discloses irreversibility and cascading deletion of tasks, which are important behavioral traits. However, it does not mention permission requirements, side effects, or any potential failure modes.

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

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

The description is extremely concise: two sentences, no fluff, front-loaded with the key verb and resource. Every word serves a purpose.

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

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

For a simple delete operation with no output schema, the description covers the core action and irreversibility. However, it lacks any mention of the return value or confirmation response, which would help an agent understand the tool's behavior completely.

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

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

Schema description coverage is 0% (no parameter descriptions in input schema). The description does not explain either parameter ('account', 'tasklist_id') at all. It adds no meaning beyond what the parameter names imply.

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 clearly identifies the resource 'a task list', noting that it deletes all associated tasks. The word 'Irreversible' adds emphasis. This clearly distinguishes from sibling tools like tasklist_create or tasklist_list.

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 vs alternatives, no prerequisites, and no exclusions. It simply states what the tool does, leaving the agent to infer usage from the tool name alone.

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 exist, so the description carries full burden. It identifies this as a read operation and mentions output fields, but lacks disclosure of pagination, error conditions, or authentication requirements. Adequate for a simple list 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, front-loaded with the action, and contains no superfluous words. It is appropriately sized for the tool's simplicity.

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

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

For a low-complexity tool with one parameter and no output schema, the description is mostly complete, mentioning the output structure. Lacks mention of array formatting or potential empty results, but these are minor omissions.

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

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

The schema has one required parameter 'account' with 0% description coverage. The description does not explain the account parameter (e.g., format like email). The name is somewhat self-explanatory, but the description adds no 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 clearly states the verb 'list' and the resource 'task lists', and distinguishes from siblings like tasklist_create and tasklist_delete by indicating it is a read operation. The output format (id + title) is specified.

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 listing all task lists but provides no explicit guidance on when to use this tool versus alternatives (e.g., task_list for tasks within a list) or prerequisites like account format.

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 is expected to disclose behavioral traits. It only states the effect (repositioning) but does not mention side effects (e.g., does it affect subtask relationships?), permissions required, or reversibility. The lack of detail leaves the agent uninformed about consequences.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the core action and the two placement options.

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 5 parameters, no output schema, and no annotations, the description is too brief. It omits details about required parameters, the meaning of 'tasklist_id', and the absence of return value or side effects. The tool's behavior is only partially described.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning for 'parent' (as subtask) and 'previous' (after in list), but does not explain 'account', 'task_id', or 'tasklist_id' (though the latter has a default). The explanation is partially helpful but incomplete.

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 'Reposition' and identifies the resource as 'task', clearly indicating it moves a task. It distinguishes from siblings like task_update or task_complete by specifying the repositioning action and the two ways to do it (under parent as subtask, after previous).

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 repositioning tasks but does not explicitly state when to use this tool vs alternatives like task_update (which could also modify positions) or when not to use it. No exclusions or context 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 must disclose behavioral traits. It notes that setting status='completed' completes the task, which is a specific behavior. However, it does not describe other potential side effects, idempotency, or permission requirements, leaving gaps 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 very concise and front-loaded, with no wasted words. It packs purpose and a usage hint into a single sentence. However, it could be slightly more structured (e.g., separating usage notes) to improve 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?

Given the absence of output schema and 7 parameters with no schema descriptions, the description is incomplete. It does not explain return values or how to use most parameters, relying heavily on the user's prior knowledge. The sibling tools provide some context but the description itself is insufficient.

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 7 parameters with 0% description coverage. The description only mentions the 'status' parameter and its effect, leaving the remaining 6 parameters (account, task_id, tasklist_id, title, notes, due) unexplained. This insufficiently compensates for the low 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 'Patch a task's fields,' which is a specific verb+resource. It also distinguishes from sibling tool 'task_complete' by noting that setting status='completed' completes it or use the dedicated tool.

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

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

The description mentions an alternative (task_complete) for the specific action of completing a task, giving some guidance on when to use this tool versus another. However, it does not provide explicit when-not-to-use guidance or broader usage context.

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