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

No annotations are provided, so the description carries full burden. It states the tool appends text, implying a write/mutation operation, but does not disclose behavioral traits such as required permissions, authentication needs (though 'user_google_email' hints at this), rate limits, or what happens if the document doesn't exist. The description adds minimal context beyond the basic 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 front-loaded with the core purpose in the first sentence, followed by a structured 'Args:' section that efficiently lists parameters. Every sentence earns its place with no wasted words, making it easy to scan and understand quickly.

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

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

Given the tool's complexity (a mutation operation with 3 parameters), no annotations, and an output schema (which reduces need to describe return values), the description is moderately complete. It covers the basic action and parameters but lacks details on authentication, error handling, or behavioral constraints, leaving gaps for safe and 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?

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for all three parameters: 'user_google_email' (identifies the user), 'document_id' (identifies the document), and 'text' (content to append). This adds meaningful context beyond the bare schema types, though it doesn't specify formats (e.g., email validation, document ID structure).

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

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

The description clearly states the specific action ('Append text'), target resource ('to the end of a Google Doc'), and distinguishes it from sibling tools like 'modify_doc_text_tool' (which likely edits rather than appends) and 'get_doc_content_tool' (which reads rather than writes). It uses a precise verb and identifies the exact resource type.

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

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

The description implies usage when text needs to be added to the end of a Google Doc, but does not explicitly state when to use this tool versus alternatives like 'modify_doc_text_tool' or 'create_doc_tool'. It provides basic context but lacks explicit exclusions or named alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'appends values' (implying a write operation) and mentions the 'value_input' parameter with options, but doesn't address critical behavioral aspects like required permissions, authentication needs, rate limits, error handling, or what the output contains. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is well-structured with a clear purpose statement followed by an 'Args:' section detailing each parameter. It's appropriately sized with no redundant information. The only minor improvement would be integrating the parameter details more seamlessly, but it remains efficient 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's complexity (a write operation with 5 parameters), no annotations, and an output schema (which reduces the need to describe return values), the description is partially complete. It excels in parameter semantics but lacks behavioral context like authentication, permissions, or error handling. It's adequate for basic use but insufficient for robust agent 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 must fully compensate. It provides clear semantic explanations for all 5 parameters: 'user_google_email' (identifies the user), 'spreadsheet_id' (identifies the sheet), 'range' (A1 notation with examples), 'values' (2D array with an example), and 'value_input' (interpretation options with enum values). This adds substantial meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Append values to a Google Sheet') and resource ('Google Sheet'), with the parenthetical 'adds rows after existing data' providing precise operational detail. It effectively distinguishes this from sibling tools like 'update_sheet_values_tool' (which modifies existing cells) and 'get_sheet_values_tool' (which reads 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?

The description implies usage through the phrase 'adds rows after existing data,' suggesting this is for adding new data rather than modifying existing cells. However, it doesn't explicitly state when to use this tool versus alternatives like 'update_sheet_values_tool' or provide any prerequisites or exclusions. The guidance is present 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?

No annotations are provided, so the description carries full burden. It mentions the OAuth flow completion but lacks critical behavioral details such as what happens upon completion (e.g., token storage, error handling, or authentication state changes). This is a significant gap for a security-sensitive 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 appropriately sized and front-loaded, with a clear purpose statement followed by a concise parameter explanation. Every sentence adds value without redundancy, making it efficient for an AI agent.

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

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

Given that an output schema exists, the description does not need to explain return values. However, as a complex authentication tool with no annotations, it lacks details on behavioral outcomes (e.g., what 'completion' entails). The parameter explanation is strong, but overall completeness is moderate due to missing operational 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 schema description coverage is 0%, but the description compensates fully by explaining the 'redirect_url' parameter in detail, including its purpose and an example format ('looks like: http://localhost/?code=4/0A...&scope=...'). This adds essential meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Complete the Google OAuth flow') and identifies the resource involved ('with the redirect URL'). It distinguishes itself from sibling tools like 'start_google_auth_tool' by focusing on the completion phase rather than initiation.

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

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

The description implies usage context by referencing 'the redirect URL from the browser after authorization,' suggesting it should be used after an OAuth flow has been initiated. However, it does not explicitly state when NOT to use it or name alternatives like 'start_google_auth_tool' for comparison.

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 but only states it 'creates' without disclosing behavioral traits like required permissions, whether this is a destructive operation, rate limits, or what the deployment entails. It mentions default behavior for 'version_description' but lacks broader context about the deployment process.

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 appropriately sized with a clear purpose statement followed by parameter explanations in a structured format. Every sentence adds value, though the 'Args:' section could be integrated more smoothly rather than as a separate block.

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 that there's an output schema (which handles return values), no annotations, and 3 parameters with 0% schema coverage, the description provides adequate parameter semantics but lacks behavioral context for a creation tool. It's minimally complete but leaves gaps in usage guidelines and transparency.

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 meaningful context for all three parameters: clarifying that 'script_id' refers to 'script project ID', 'description' is for the deployment, and 'version_description' is optional with default behavior. This provides semantic understanding beyond the bare schema.

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

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

The description clearly states the action ('Create a new deployment') and resource ('of the script'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'create_version_tool' or 'update_deployment_tool', which would require more specific context about what distinguishes a deployment from a version or update operation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'create_version_tool' or 'update_deployment_tool', nor are there any prerequisites or contextual constraints mentioned. The description only lists parameters without indicating appropriate usage 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 are provided, so the description carries the full burden of behavioral disclosure. It states the tool creates a new Google Doc, implying a write operation, but doesn't mention permissions needed (e.g., whether the user_google_email must have edit access), what happens on success/failure, or if there are rate limits. The description adds minimal behavioral context beyond the basic 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 front-loaded with the main purpose ('Create a new Google Doc.') followed by parameter explanations in a clear 'Args:' section. It's efficient with no redundant sentences, though the parameter explanations could be more detailed given the lack of schema descriptions.

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

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

Given the tool's complexity (a write operation with 3 parameters), no annotations, and an output schema (which means return values are documented elsewhere), the description is moderately complete. It covers the basic action and parameters but lacks behavioral details like error handling or permissions. With an output schema, it doesn't need to explain return values, but more context on usage and behavior would improve completeness.

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 schema provides no parameter descriptions. The description adds some semantics by explaining 'user_google_email: The user's Google email address', 'title: Document title', and 'content: Optional initial content', which clarifies purpose and optionality. However, it doesn't cover format details (e.g., email validation, content constraints) or default behavior for 'content', leaving gaps.

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

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

The description clearly states the tool's purpose: 'Create a new Google Doc.' This specifies the verb ('Create') and resource ('Google Doc'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'create_drive_file_tool' or 'create_spreadsheet_tool' beyond mentioning 'Google Doc' specifically.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'create_drive_file_tool' (which might create other file types) or 'append_doc_text_tool' (which modifies existing docs), nor does it specify prerequisites like authentication or document location. The only implied usage is for creating new Google Docs, but without context about alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While it clearly indicates this is a creation operation, it doesn't mention important behavioral aspects like: what permissions are required, whether the file is immediately visible to others, what happens if a file with the same name exists, error conditions, or what the output contains. The description is minimal and lacks operational context.

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

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

The description is well-structured with a clear purpose statement followed by parameter explanations. It's appropriately sized for a 5-parameter tool, though the parameter explanations could be more detailed. Every sentence serves a purpose, with no redundant information. The formatting with 'Args:' section makes it easy to scan.

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 that this is a creation tool with no annotations, 5 parameters (2 required), 0% schema description coverage, but with an output schema present, the description is moderately complete. It covers the basic purpose and parameters but lacks important contextual information about permissions, error handling, and differentiation from sibling tools. The presence of an output schema means the description doesn't need to explain return values, but other gaps remain.

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

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

The description provides clear semantic explanations for all 5 parameters beyond what the schema shows (which has 0% description coverage). It explains what each parameter represents (e.g., 'user's Google email address', 'Parent folder ID', 'MIME type of the file') and provides default values. This significantly compensates for the schema's lack of descriptions, though it could provide more context about valid formats or constraints.

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 a new file') and resource ('in Google Drive'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'create_doc_tool' or 'create_spreadsheet_tool' which also create files in Drive, leaving some ambiguity about when to use this specific file creation 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 provides no guidance on when to use this tool versus alternatives like 'create_doc_tool' or 'create_spreadsheet_tool'. It mentions default values for folder_id and mime_type but doesn't explain when to override them or what other MIME types might be appropriate. There's no mention of prerequisites, permissions needed, or typical 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?

No annotations are provided, so the description carries full burden. It states the tool creates a folder but doesn't disclose behavioral traits like required permissions, whether it returns the new folder's ID, error conditions (e.g., duplicate names), or side effects. 'Create' implies a mutation, but details are missing.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by a structured Args section. Every sentence earns its place by providing essential information without redundancy.

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

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

Given the tool's moderate complexity (3 parameters, mutation operation) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the basic purpose and parameters but lacks behavioral details like error handling or permissions, which are important for a creation 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 adds meaningful context for all three parameters: user_google_email clarifies it's the user's email, folder_name specifies it's for naming, and parent_id explains the default 'root' value. This goes beyond the bare schema 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?

The description clearly states the specific action ('Create a new folder') and resource ('in Google Drive'), distinguishing it from sibling tools like create_drive_file_tool (which creates files) and list_drive_items_tool (which lists items). The verb+resource combination is precise and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication status), differentiate from similar creation tools (e.g., create_drive_file_tool), or specify use cases. The agent must 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?

With no annotations provided, the description carries full burden but only states the action ('Create a new calendar event') without disclosing behavioral traits. It doesn't mention required permissions, whether the event is immediately saved or requires confirmation, error handling, or rate limits. The description is minimal and lacks essential operational context 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 appropriately sized and front-loaded with the core purpose in the first sentence. The parameter explanations are organized in a clear list format, though some redundancy exists (e.g., repeating format examples for start/end times). Every sentence adds value, but minor trimming could improve efficiency.

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 (9 parameters, mutation operation) and no annotations, the description is partially complete. It excels in parameter documentation but lacks behavioral context (e.g., permissions, side effects). The presence of an output schema reduces the need to explain return values, but for a creation tool with no annotations, more operational guidance is needed to be fully adequate.

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

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

The description adds significant meaning beyond the input schema, which has 0% schema description coverage. It explains each parameter's purpose (e.g., 'user_google_email: The user's Google email address'), provides format examples for 'start_time' and 'end_time', clarifies defaults (e.g., 'calendar_id: Calendar ID (default: 'primary')'), and explains conditional behavior ('all_day: If True, create an all-day event'). This fully compensates 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 the specific action ('Create a new calendar event') and identifies the resource ('calendar event'). It distinguishes from sibling tools like 'get_events_tool' (read) and 'update_event_tool' (modify) by specifying creation rather than retrieval or modification.

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 'update_event_tool' or 'delete_event_tool'. The description lacks context about prerequisites (e.g., authentication) or scenarios where this tool is appropriate, offering only basic parameter explanations without usage context.

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

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

With no annotations provided, the description carries full burden and does well by explaining the two creation modes (standalone/bound) and the capabilities of bound scripts (custom menus, triggers, getActiveSpreadsheet()). However, it doesn't mention authentication requirements, rate limits, or error conditions that would be helpful 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 well-structured with a clear opening statement followed by parameter documentation. While slightly longer than minimal, every sentence adds value: the first establishes purpose, the parameter section provides essential usage details, and the final sentence explains bound script capabilities.

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

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

For a mutation tool with no annotations, the description provides good coverage of purpose, parameters, and usage context. The existence of an output schema reduces the need to describe return values. However, it could better address behavioral aspects like permissions or error handling given it's a creation 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?

With 0% schema description coverage, the description fully compensates by providing detailed semantic information for both parameters: it explains that 'title' is the project title, and 'parent_id' is optional for binding to specific Google document types, with clear examples of valid IDs and the consequences of leaving it empty.

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

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

The description clearly states the specific action ('Create a new Apps Script project') and distinguishes between two resource types (standalone or bound to a document). It differentiates from sibling tools like create_doc_tool or create_spreadsheet_tool by focusing specifically on Apps Script projects, not general document creation.

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

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

The description provides explicit guidance on when to use this tool vs alternatives: it explains when to create standalone vs bound scripts, specifies which document types can be bound, and mentions that bound scripts enable document-specific features. This gives clear context for choosing between the two modes.

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. While 'Create' implies a write operation, it doesn't specify required permissions, whether the spreadsheet is created in a specific location (e.g., user's Drive root), ownership details, error conditions, or what happens if a spreadsheet with the same title exists. This leaves significant behavioral 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 appropriately sized with a clear main statement followed by parameter explanations. The Args section is well-structured, though the formatting could be slightly more integrated. Every sentence adds value with no redundant 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 this is a mutation tool with no annotations but with an output schema (which handles return values), the description is moderately complete. It covers the core purpose and parameters well, but lacks important behavioral context about permissions, location, and error handling that would be expected for a creation tool in this ecosystem.

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 provides meaningful context for all three parameters: user_google_email identifies the owner, title specifies the spreadsheet name, and sheet_names explains the optional sheet creation with default value. This adds substantial semantic value beyond the bare schema 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?

The description clearly states the specific action ('Create a new Google Spreadsheet') and identifies the resource type. It distinguishes itself from sibling tools like create_doc_tool or create_drive_file_tool by specifying it creates spreadsheets specifically, not other Google Workspace file types.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (like authentication), compare with similar tools (like create_drive_file_tool which might also create spreadsheets), or indicate when this is the appropriate choice among creation tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates key behavioral traits: that versions are 'immutable' and 'cannot be modified once created,' which is crucial for understanding the tool's impact. However, it doesn't mention authentication requirements, rate limits, or what happens if the script_id doesn't exist.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by clarifying sentences about versions and immutability, then a structured 'Args:' section. Every sentence earns its place with no wasted words, making it easy to scan and understand.

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

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

Given the tool's moderate complexity (creating immutable versions), no annotations, and the presence of an output schema, the description is mostly complete. It covers purpose, behavior, and parameters well. However, it could benefit from mentioning prerequisites (e.g., needing an existing script project) or typical use cases, though the output schema reduces the need to explain return values.

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

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

Schema description coverage is 0%, so the description must fully compensate. It successfully adds meaning beyond the bare schema by explaining both parameters: 'script_id' as 'The script project ID' and 'description' as 'Optional description for this version.' This clarifies the purpose and optional nature of each parameter, which the schema alone doesn't provide.

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

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

The description clearly states the tool's purpose with specific verbs ('Create a new immutable version') and resource ('script project'), distinguishing it from siblings like 'create_script_project_tool' or 'update_script_content_tool'. It explicitly defines what versions are ('capture a snapshot of the current script code') and their immutable nature.

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

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

The description provides clear context for when to use this tool: to create immutable versions of script projects. It doesn't explicitly mention when not to use it or name alternatives, but the context is sufficient to differentiate it from sibling tools like 'update_script_content_tool' (for modifying code) or 'get_version_tool' (for retrieving versions).

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 ('Delete') without behavioral details. It doesn't mention if deletion is permanent, requires specific permissions, affects associated resources, or has side effects like triggering notifications, leaving significant gaps for a destructive operation.

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

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

The description is front-loaded with the core action ('Delete a deployment') and uses a structured 'Args:' section for parameters, making it efficient. However, the parameter explanations are minimal and could be more integrated, slightly reducing structural 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?

For a destructive tool with no annotations and 2 parameters, the description is incomplete. It doesn't cover behavioral aspects like permanence or permissions, and while an output schema exists, the description doesn't hint at return values or error conditions, leaving the agent under-informed for safe use.

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

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

Schema description coverage is 0%, but the description adds basic semantics by explaining 'script_id' as 'The script project ID' and 'deployment_id' as 'The deployment ID to delete'. This clarifies the purpose of both parameters, though it lacks format details or examples, providing moderate value beyond the bare 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 ('Delete') and resource ('a deployment'), making the purpose unambiguous. However, it doesn't differentiate from sibling tools like 'delete_drive_file_tool' or 'delete_script_project_tool' beyond the resource type, which keeps it from a perfect score.

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 'update_deployment_tool' or 'list_deployments_tool'. The description lacks context about prerequisites, such as needing an existing deployment, or warnings about irreversible deletion.

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 effectively communicates the destructive nature ('permanently delete', 'WARNING'), which is critical for a mutation tool. However, it lacks details on permissions needed, error conditions, or what happens to shared links, leaving some behavioral aspects uncovered.

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 front-loaded with the core action and warning, followed by parameter explanations. Every sentence adds value: the first states the purpose, the second provides critical usage guidance, and the parameter section clarifies inputs without redundancy. It's efficiently structured with zero waste.

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

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

Given that this is a destructive mutation tool with no annotations, the description does well by highlighting permanence and providing an alternative. The presence of an output schema means return values need not be explained. However, for a high-stakes operation, additional context on permissions or error handling would enhance completeness.

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 meaningful context for both parameters: 'user_google_email' is explained as 'The user's Google email address' and 'file_id' as 'The file ID to delete'. This clarifies what each parameter represents, though it doesn't specify format constraints (e.g., email validation or ID structure).

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

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

The description clearly states the specific action ('permanently delete') and target resource ('a file from Google Drive'). It distinguishes itself from the sibling tool 'trash_drive_file' by emphasizing the permanent nature of deletion, making the purpose unambiguous and differentiated.

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

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

The description provides explicit guidance on when to use this tool vs. alternatives: it warns that this is for permanent deletion and explicitly names 'trash_drive_file' as the alternative for recoverable deletion. This gives clear context for tool selection.

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 tool deletes an event but doesn't clarify if this is permanent, reversible, requires specific permissions, or has side effects (e.g., notifications). For a destructive operation, this lack of detail is a significant gap.

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

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

The description is efficiently structured with a clear purpose statement followed by a parameter list. Every sentence earns its place, and it's front-loaded with the core action. No wasted words or redundancy.

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

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

Given the tool's destructive nature, lack of annotations, and an output schema (which may cover return values), the description is incomplete. It adequately explains parameters but misses critical behavioral details like permissions, reversibility, and error handling, leaving gaps for safe 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?

The description explicitly lists all three parameters with brief explanations, including the default value for 'calendar_id'. Since schema description coverage is 0%, this compensates well by providing essential context beyond the bare schema, though it doesn't detail formats (e.g., email validation, event ID structure).

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 ('Delete') and resource ('calendar event'), making it immediately understandable. It distinguishes itself from siblings like 'create_event_tool' and 'update_event_tool' by focusing on removal rather than creation or modification.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication), conditions for use (e.g., event ownership), or what happens if the event doesn't exist. Without this context, an agent might misuse 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 carries the full burden of behavioral disclosure and excels at this. It explicitly warns about permanent deletion and irreversibility, which are critical behavioral traits for a destructive operation. This goes well beyond what a basic 'delete' description would provide.

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 perfectly structured and front-loaded: the core purpose in the first sentence, critical warning in the second, and parameter explanation in a clear Args section. Every sentence earns its place with zero wasted words or redundancy.

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

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

For a destructive single-parameter tool with no annotations, the description provides complete context: clear purpose, critical behavioral warnings, and parameter explanation. The existence of an output schema means return values don't need explanation. This is comprehensive for its complexity level.

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 for the single parameter, the description fully compensates by explaining what 'script_id' represents ('The script project ID to delete'). This adds essential meaning beyond the bare schema. It doesn't specify format requirements (like whether it's numeric or alphanumeric), keeping it from a perfect score.

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

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

The description clearly states the specific action ('Delete') and resource ('Apps Script project'), distinguishing it from sibling tools like delete_drive_file_tool or delete_event_tool. It provides a complete verb+resource statement that leaves no ambiguity about what this tool does.

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

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

The description provides clear context about when to use this tool (to delete an Apps Script project) and includes a strong warning about permanent deletion. However, it doesn't explicitly mention when NOT to use it or name specific alternatives (like trash_drive_file_tool for reversible deletion), which prevents a perfect score.

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 clearly explains that this tool generates code rather than executing actions directly ('Generate Apps Script code'), describes the output ('Apps Script code to create the trigger'), and provides important usage instructions ('User should add this to their script and run the setup function once to install the trigger'). However, it doesn't mention potential limitations like rate limits, authentication requirements, or error conditions.

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 well-structured and appropriately sized. It starts with the core purpose, provides necessary context about API limitations, then details parameters in a clear format, and concludes with return value and usage instructions. Every sentence serves a specific purpose with no wasted words.

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 (generating executable code), 0% schema description coverage, no annotations, but with an output schema present, the description provides excellent completeness. It explains the tool's purpose, API constraints, detailed parameter semantics, return value format, and post-generation usage instructions. The presence of an output schema means the description doesn't need to detail return structure, allowing it to focus on conceptual 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?

With 0% schema description coverage, the description fully compensates by providing comprehensive parameter documentation. It clearly explains all three parameters (trigger_type, function_name, schedule) with detailed semantics, including enumerated values for trigger_type, format requirements for schedule based on trigger_type, and when schedule is not needed. This adds significant value beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Generate Apps Script code for creating triggers.' It specifies the exact action (generate code) and resource (Apps Script triggers), and distinguishes itself from siblings by explaining the unique constraint that 'Apps Script API cannot create triggers directly - they must be created from within Apps Script itself.' This provides clear differentiation from other tools that might directly manipulate resources.

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 explicitly states when to use this tool: 'The Apps Script API cannot create triggers directly... This tool generates the code you need.' It provides clear context about the limitation of the API and positions this tool as the solution for creating triggers, effectively distinguishing it from any potential alternatives that might attempt direct trigger 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 carries the full burden of behavioral disclosure. While 'Get' implies a read operation, the description doesn't specify what 'content' includes (e.g., text, formatting, images), whether it requires specific permissions, or if there are rate limits. It mentions two required parameters but doesn't explain their behavioral significance (e.g., why both email and document ID are needed).

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 appropriately sized with a clear purpose statement followed by parameter explanations. It uses a simple two-part structure (purpose + args) without unnecessary elaboration. However, the 'Args:' section could be more integrated into the flow rather than a separate block, and there's room to make it more front-loaded by emphasizing key constraints earlier.

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 that there's an output schema (which handles return values), no annotations, and low schema coverage (0%), the description does a minimal job. It states the purpose and parameters but lacks behavioral context (e.g., permissions, error handling) and usage guidance. For a tool with two required parameters and no annotation support, this leaves the agent with incomplete operational understanding despite the output schema.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds basic semantics by naming and briefly describing the two parameters ('user_google_email: The user's Google email address' and 'document_id: The document ID'), which helps understand what each parameter represents. However, it doesn't provide format details (e.g., email validation, document ID structure) or explain why both are required, leaving gaps.

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: 'Get the content of a Google Doc.' This is a specific verb ('Get') and resource ('Google Doc content'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'get_drive_file_content_tool' or 'get_script_content_tool' that also retrieve content from different Google services.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_docs_tool' for finding documents first or 'modify_doc_text_tool' for editing content. There's no context about prerequisites (e.g., authentication status) or when this tool is appropriate versus other content retrieval tools in the sibling list.

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 mentions the tool 'Supports Google Docs (-> text), Sheets (-> CSV), Slides (-> text), and text files' which adds useful context about output format conversions. However, it doesn't disclose critical behavioral traits like authentication requirements (though 'user_google_email' parameter hints at this), rate limits, file size limitations, error conditions, or whether this is a read-only operation. For a content retrieval tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is efficiently structured with a clear purpose statement followed by supported file types, then parameter documentation. Every sentence earns its place: the first states the core function, the second adds important format conversion context, and the third documents parameters. No wasted words, well front-loaded with the most important information first.

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

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

Given the tool's moderate complexity (content retrieval with format conversions), no annotations, and the presence of an output schema (which handles return value documentation), the description is reasonably complete. It covers purpose, supported file types, and parameter semantics. The main gap is insufficient behavioral context (authentication, limitations, error handling), but the output schema reduces the need to describe return values. For a read operation, this is adequate though not comprehensive.

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

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

The description explicitly documents both parameters in the 'Args:' section, providing clear semantic meaning: 'user_google_email: The user's Google email address' and 'file_id: The Drive file ID'. With 0% schema description coverage (schema has no descriptions), this fully compensates by adding essential parameter context that the schema lacks. The parameter documentation is complete and meaningful for both 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 purpose: 'Get the content of a Google Drive file' with specific verb ('Get') and resource ('Google Drive file content'). It distinguishes from siblings like 'get_doc_content_tool' and 'get_sheet_values_tool' by mentioning broader file type support (Docs, Sheets, Slides, text files). However, it doesn't explicitly differentiate from 'list_drive_items_tool' which lists metadata rather than content.

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

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

The description implies usage context by specifying supported file types (Google Docs, Sheets, Slides, text files), suggesting when this tool is appropriate. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_doc_content_tool' or 'get_sheet_values_tool', nor does it mention prerequisites or exclusions. The sibling tool list shows specialized content tools, but no comparison is made.

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 mentions the tool 'Get events' but doesn't specify if it's read-only, requires authentication, has rate limits, or what the output looks like. This leaves significant gaps in understanding the tool's behavior beyond basic functionality.

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 well-structured with a clear opening sentence followed by detailed parameter explanations. It's appropriately sized for a tool with 6 parameters, though the parameter list could be slightly more concise. Every sentence adds value, making it 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 tool's moderate complexity (6 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameters well but lacks behavioral context and usage guidelines. The presence of an output schema means return values don't need explanation, but other gaps remain.

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

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

The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose, defaults, and formats (e.g., 'ISO format', 'default: primary'), effectively compensating for the schema's lack of documentation. This is crucial given the 6 parameters involved.

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

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

The description clearly states the verb ('Get') and resource ('events from a calendar'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_calendars_tool' or 'create_event_tool' beyond the basic function, which prevents a perfect score.

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 'list_calendars_tool' or 'create_event_tool'. The description only explains what the tool does, not the context or prerequisites for its use, leaving the agent without usage direction.

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 action ('Get') but does not mention permission requirements, rate limits, error handling, or response format. For a read operation with zero annotation coverage, this leaves significant gaps in understanding tool behavior.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose in the first sentence. The 'Args:' section is structured but slightly redundant with the schema; however, it adds value by clarifying parameter meanings efficiently without unnecessary detail.

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

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

Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is adequate but incomplete. It covers parameters well but lacks behavioral context like authentication needs or error cases. The presence of an output schema reduces the need to explain return values, but more operational details would improve completeness.

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

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

The description adds meaningful context for all three parameters beyond the schema, which has 0% description coverage. It explains 'user_google_email' as the user's email, 'message_id' as the ID to retrieve, and 'format' with its enum values ('full', 'metadata', 'minimal'), compensating well 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 the specific action ('Get'), resource ('Gmail message'), and scope ('by ID'), making the purpose explicit. It distinguishes this tool from siblings like 'search_gmail_messages_tool' (which searches) and 'send_gmail_message_tool' (which sends), avoiding redundancy with the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'search_gmail_messages_tool' or 'list_gmail_labels_tool'. It lacks context about prerequisites (e.g., authentication) or exclusions, offering only basic usage without comparative advice.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a retrieval operation, implying it's likely read-only and non-destructive, but doesn't explicitly confirm this or mention any constraints like authentication needs, rate limits, or error conditions. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose, followed by a structured 'Args:' section. There's no wasted text, though the formatting could be slightly more polished (e.g., using bullet points). Every sentence earns its place.

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

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

Given the tool's moderate complexity (2 required parameters), no annotations, and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose and parameter semantics adequately. However, it lacks behavioral context (e.g., safety, errors) and usage guidelines, which holds it back from a perfect score.

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

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

Schema description coverage is 0%, so the description must compensate. It provides clear semantics for both parameters: 'script_id: The script project ID' and 'file_name: Name of the file to retrieve (e.g., "Code", "appsscript")'. This adds meaningful context beyond the bare schema, though it doesn't cover all possible nuances (e.g., file name constraints or script ID format).

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: 'Retrieve content of a specific file within a project.' This is a specific verb ('Retrieve') + resource ('content of a specific file within a project'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_doc_content_tool' or 'get_drive_file_content_tool' beyond the project context, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing script project), exclusions, or comparisons to sibling tools like 'get_script_project_tool' or 'get_version_tool'. The agent must infer usage from the purpose 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 are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns analytics data, which implies a read-only operation, but doesn't explicitly confirm if it's safe or has side effects. It also doesn't mention any constraints like authentication requirements, rate limits, or data freshness, which are critical for a metrics tool. The description adds minimal behavioral context beyond the basic purpose.

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 appropriately sized and front-loaded: the first sentence states the purpose, the second explains the return data, and the 'Args' section clearly documents parameters. Every sentence earns its place with no redundant information, making it efficient 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?

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the purpose, return data, and parameter semantics. Since an output schema exists, it doesn't need to detail return values. However, it lacks behavioral context like safety or constraints, which would enhance completeness for a tool with no annotations.

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

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

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains that 'script_id' is for a script project ID and 'metrics_granularity' controls the time granularity with allowed values 'DAILY' or 'WEEKLY', including the default. This compensates well for the schema's lack of descriptions, making the parameters clear and actionable.

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: 'Get execution metrics for a script project' with specific analytics data listed. It uses a specific verb ('Get') and resource ('execution metrics for a script project'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_script_project_tool' or 'list_script_projects_tool', which focus on different aspects of script projects.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing an existing script project, or compare it to sibling tools like 'get_script_project_tool' (which retrieves project details) or 'list_script_projects_tool' (which lists projects). The absence of usage context leaves the agent to infer when this tool is appropriate.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states 'Retrieve' implying a read operation, but doesn't disclose permissions needed, rate limits, error conditions, or what 'complete project details' includes beyond 'all source files'. This is inadequate for a tool with no annotation coverage.

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 appropriately concise with two sentences: one stating the purpose and one explaining the parameter. It's front-loaded with the core functionality. The structure is clear, though the parameter explanation could be integrated more smoothly.

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 an output schema (which handles return values), no annotations, and simple parameters, the description is minimally complete. It states what the tool does and documents the parameter, but lacks behavioral context and usage guidance, making it adequate but with clear gaps for effective agent use.

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

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

Schema description coverage is 0%, but the description adds the parameter 'script_id' with a brief explanation ('The script project ID'). This provides basic semantics beyond the bare schema. However, with only 1 parameter documented out of 1 (100% coverage by description), and no details on format or constraints, it meets the baseline for minimal viable documentation.

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

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

The description clearly states the action ('Retrieve') and resource ('complete project details including all source files'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_script_content_tool' or 'get_script_metrics_tool', which appear to retrieve different aspects of script projects.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_script_projects_tool' for listing projects or 'get_script_content_tool' for specific content retrieval, 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Get values') but doesn't describe important behavioral aspects: whether this requires specific permissions, what happens if the range is invalid, whether there are rate limits, what authentication is needed beyond the email parameter, or what the output format looks like. The description is minimal and lacks operational context.

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

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

The description is well-structured and appropriately sized. It starts with a clear purpose statement, then provides a parameter section with helpful explanations. Each sentence earns its place by adding necessary information. The only minor improvement would be integrating the purpose and parameters more seamlessly.

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 that there's an output schema (which handles return values), no annotations, and the description provides good parameter semantics, this is adequate but has clear gaps. The description doesn't address behavioral aspects like authentication requirements, error conditions, or usage context. For a data retrieval tool with 4 parameters and no annotations, more operational guidance would be helpful.

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 provides clear semantic explanations for all 4 parameters beyond what the schema offers. The schema has 0% description coverage (just type definitions), but the description explains: 'user_google_email: The user's Google email address', 'spreadsheet_id: The spreadsheet ID', 'range: A1 notation range', and 'value_render: How values should be rendered' with specific enum values. This adds substantial value over the bare schema.

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

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

The description clearly states the tool's purpose: 'Get values from a Google Sheet.' This specifies the verb ('Get') and resource ('Google Sheet'), making it immediately understandable. However, it doesn't differentiate from sibling tools like 'get_spreadsheet_metadata_tool' or 'get_doc_content_tool' that also retrieve information from Google Workspace products.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of when this tool is appropriate compared to other data retrieval tools in the sibling list, nor any prerequisites or constraints for usage. The agent must 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 are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves metadata, implying a read-only operation, but does not cover aspects like authentication requirements, rate limits, error handling, or what specific metadata is returned (e.g., sheet properties beyond names). This is a significant gap for a tool with no annotation support.

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

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

The description is concise and front-loaded, with the main purpose stated first followed by parameter details. It avoids unnecessary words, though the parameter descriptions could be more informative. The structure is clear, but it could benefit from better organization or bullet points for readability.

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 that there is an output schema (which handles return values), the description does not need to explain outputs. However, with no annotations, 0% schema coverage, and two parameters, the description lacks details on authentication, error cases, and parameter semantics. It provides a basic overview but misses key contextual elements for a tool in this environment.

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 schema provides no parameter details. The description adds minimal semantics by listing the parameters ('user_google_email' and 'spreadsheet_id') and briefly describing them, but it does not explain format requirements (e.g., email validation, ID structure) or usage context. This partially compensates for the schema gap but is insufficient for full clarity.

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: 'Get metadata about a spreadsheet including all sheet names and properties.' It specifies the verb ('Get'), resource ('spreadsheet'), and scope ('metadata'), but does not explicitly differentiate it from sibling tools like 'get_sheet_values_tool' or 'list_spreadsheets_tool', which is why it scores 4 instead of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'get_sheet_values_tool' (for data) or 'list_spreadsheets_tool' (for listing), nor does it specify prerequisites or exclusions. This lack of context leaves the agent without clear usage instructions.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. It only states the basic action ('Get details') without mentioning permissions, rate limits, response format, or error handling. For a read operation in a Google Scripts context, this lacks critical context like authentication needs or data sensitivity.

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 appropriately sized and front-loaded: the first sentence states the purpose, followed by a structured 'Args:' section. Every sentence adds value, with no wasted words. A 5 would require even tighter phrasing or bullet points for optimal scanning.

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

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

Given the tool's moderate complexity (2 required parameters) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and low schema coverage, it should provide more behavioral context (e.g., read-only nature, error cases) to be fully complete for safe agent use.

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

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

Schema description coverage is 0%, so the description compensates by explaining both parameters: 'script_id: The script project ID' and 'version_number: The version number to retrieve (1, 2, 3, etc.)'. This adds clear meaning beyond the bare schema, though it doesn't cover format details (e.g., ID structure) or constraints beyond examples.

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: 'Get details of a specific version.' This specifies the verb ('Get details') and resource ('a specific version'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'list_versions_tool' or 'get_script_project_tool,' which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_versions_tool' (for listing versions) or 'get_script_project_tool' (for project-level details), nor does it specify prerequisites or contextual constraints. This leaves the agent without clear usage direction.

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 but offers minimal behavioral insight. It mentions 'accessible to the user' which hints at permission-based filtering, but doesn't disclose pagination behavior, rate limits, error conditions, or what 'all calendars' includes (e.g., primary vs. secondary). For a read operation with zero annotation coverage, this is inadequate.

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 efficiently structured with a clear purpose statement followed by parameter documentation. Both sentences earn their place, though the Args formatting could be more integrated. No redundant or verbose language is present.

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

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

Given the tool's low complexity (single parameter, read-only list operation) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and incomplete behavioral disclosure, it leaves gaps in understanding error handling and operational constraints.

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%, but the description includes an Args section that documents the single parameter 'user_google_email' with a brief explanation. This adds meaningful context beyond the bare schema, though it doesn't specify format requirements (e.g., must be a valid Google email) or authentication implications. Baseline 3 is appropriate as it compensates somewhat for the schema gap.

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

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

The description clearly states the action ('List all calendars') and resource ('accessible to the user'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling list tools like list_drive_items_tool or list_spreadsheets_tool, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (like authentication), comparison to other calendar-related tools, or typical use cases. The agent must infer usage from the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions listing deployments but doesn't specify if this is a read-only operation, what permissions are required, whether it returns all deployments or paginated results, or any rate limits. This leaves significant gaps for an AI agent to understand how to use it safely and effectively.

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 appropriately sized with two sentences: one stating the purpose and another explaining the parameter. It's front-loaded with the main action, and there's no wasted text, making it efficient 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?

Given that there's an output schema (which handles return values), no annotations, and a simple parameter (1 required), the description is somewhat complete but lacks behavioral context. It covers the basics but misses details like pagination, error handling, or relation to other tools, which could help an AI agent use it more effectively in 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 description includes an 'Args' section that documents the single parameter 'script_id' and its purpose, adding meaning beyond the input schema (which has 0% description coverage). However, it doesn't provide details like format examples (e.g., if it's a numeric ID or string) or constraints, so it only partially compensates for the schema gap.

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

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

The description clearly states the verb ('List') and resource ('deployments for a script project'), making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'list_script_projects_tool' or 'list_versions_tool' in terms of scope or hierarchy, which prevents a perfect score.

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. For example, it doesn't mention if this is for active deployments only, or how it relates to 'create_deployment_tool' or 'delete_deployment_tool'. The description only states what it does, not when it's appropriate.

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

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

No annotations are provided, so the description carries the full burden. It states the tool lists items but doesn't disclose behavioral traits like pagination behavior (e.g., how to handle multiple pages beyond the default page_size), rate limits, authentication requirements, or error handling. The description is minimal and misses key operational 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 front-loaded with the core purpose in the first sentence, followed by a structured 'Args:' section that efficiently documents parameters. Every sentence earns its place with no wasted words, making it easy to scan and understand quickly.

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

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

Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameters well but lacks behavioral context (e.g., pagination, auth). The output schema likely handles return values, so that gap is mitigated, but overall it's adequate with clear room for improvement.

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 meaningful semantics by explaining each parameter: 'user_google_email' as the user's email, 'folder_id' with its default and purpose, and 'page_size' with its default and role. This clarifies beyond the bare schema, though it could detail format constraints (e.g., email validation).

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

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

The description clearly states the tool's purpose: 'List files and folders in a Drive folder.' It specifies the verb ('List') and resource ('files and folders in a Drive folder'), making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'search_drive_files_tool' or 'get_drive_file_content_tool', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_drive_files_tool' for broader searches or 'get_drive_file_content_tool' for file details, nor does it specify prerequisites (e.g., authentication status). Usage is implied by the purpose but lacks explicit 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 carries the full burden of behavioral disclosure. It states the tool lists permissions, implying a read-only operation, but doesn't clarify authentication requirements, rate limits, error conditions, or what the output looks like (though an output schema exists). For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is appropriately sized and front-loaded, with the core purpose stated first in a clear sentence. The parameter explanations are brief and directly relevant. There's no unnecessary verbosity, though the structure could be slightly improved by integrating parameter details more seamlessly.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is minimally adequate. It covers the basic purpose and parameters but lacks behavioral context and usage guidelines. The output schema mitigates the need to explain return values, but overall completeness is limited by missing operational details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds basic semantics for both parameters ('user_google_email' and 'file_id'), explaining what they represent. However, it doesn't provide format details (e.g., email validation, ID structure) or usage context (e.g., why the user email is needed). This partial compensation meets the baseline for low coverage but doesn't fully address the gaps.

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

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

The description clearly states the tool's purpose: 'List all permissions on a file or folder.' This specifies the verb ('List') and resource ('permissions on a file or folder'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'share_drive_file_tool' or 'remove_drive_permission_tool', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'share_drive_file_tool' or 'remove_drive_permission_tool', nor does it specify prerequisites or contexts for usage. The only usage hint is implicit from the parameter descriptions, which is insufficient for clear 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?

No annotations are provided, so the description must fully disclose behavioral traits. It states the action ('List all Gmail labels') but doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication requirements, or the format of the output (e.g., pagination, error handling). This is a significant gap for a tool with no annotation support.

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

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

The description is appropriately sized and front-loaded, with the core purpose stated first in a clear sentence. The 'Args' section is concise and directly relevant. There's no wasted text, though it could be slightly more structured (e.g., bullet points) for a perfect score.

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 low complexity (one parameter) and the presence of an output schema, the description is somewhat complete. It covers the basic purpose and parameter, but lacks behavioral details (e.g., authentication, rate limits) and usage guidelines. With no annotations, it should do more to compensate, making it minimally viable but with clear gaps.

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

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

The description includes an 'Args' section that documents the single parameter 'user_google_email', adding meaning beyond the input schema, which has 0% description coverage. However, it only provides a basic label without details on format (e.g., email validation) or context (e.g., must be authenticated). With one parameter and low schema coverage, this is adequate but minimal.

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

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

The description clearly states the tool's purpose: 'List all Gmail labels for the user.' It specifies the verb ('List') and resource ('Gmail labels'), making the action unambiguous. However, it doesn't differentiate from sibling tools like 'modify_gmail_labels_tool' or 'search_gmail_messages_tool', which would require explicit comparison for a score of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'modify_gmail_labels_tool' for editing labels or 'search_gmail_messages_tool' for message-related operations, nor does it specify prerequisites such as authentication. This lack of context leaves usage unclear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists 'recent execution processes,' implying a read-only operation, but doesn't specify what 'recent' means (e.g., time range, default recency), whether it requires authentication, if there are rate limits, or the format of returned processes. For a listing tool with zero annotation coverage, this leaves significant behavioral gaps, though it's not misleading.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by a clear 'Args:' section with bullet-like formatting. There's no wasted text, and each part adds value. However, the structure could be slightly improved by integrating the parameter details more seamlessly, but it remains efficient 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?

Given the tool's moderate complexity (listing with optional filtering), no annotations, and an output schema present (which covers return values), the description is partially complete. It explains the purpose and parameters well but lacks behavioral context (e.g., recency definition, authentication needs) and usage guidelines. With the output schema handling return values, the description doesn't need to explain outputs, but it should provide more operational guidance to be fully adequate.

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 meaningful semantics for both parameters: 'page_size: Number of results (default: 50)' clarifies the purpose and default value, and 'script_id: Optional filter by script ID' explains its optional filtering role. This goes beyond the schema's basic type definitions, providing context that helps the agent understand how to use the parameters effectively, though it doesn't detail format constraints (e.g., script_id format).

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

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

The description clearly states the tool's purpose: 'List recent execution processes for user's scripts.' This specifies the verb ('List'), resource ('execution processes'), and scope ('recent', 'for user's scripts'). It distinguishes from siblings like list_script_projects_tool (which lists projects, not processes) and get_script_metrics_tool (which gets metrics, not processes). However, it doesn't explicitly differentiate from all siblings, such as list_deployments_tool, which might also involve script-related listings.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions optional filtering by script_id but doesn't specify scenarios for using this tool over other listing tools (e.g., list_script_projects_tool for projects or get_script_metrics_tool for performance data). There are no explicit when-to-use or when-not-to-use instructions, leaving the agent to infer usage from the purpose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination and default values, which is helpful, but lacks critical details such as whether this is a read-only operation, potential rate limits, error conditions, or the structure of returned data. For a list tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is appropriately sized and front-loaded, with the core purpose stated first followed by parameter details. Every sentence adds value, though the formatting with 'Args:' could be slightly more integrated. It avoids redundancy and stays focused on 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 the tool's low complexity (list operation with 2 parameters) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose and parameters adequately, though it could improve by adding usage guidelines and more behavioral context to fully compensate for the lack of annotations.

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 clearly explains both parameters: 'page_size' as 'Number of results per page (default: 50)' and 'page_token' as 'Token for pagination (optional)'. This adds meaningful semantics beyond the bare schema, though it could elaborate on pagination mechanics (e.g., how to obtain the token).

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 resource ('Google Apps Script projects accessible to the user'), making the purpose specific and unambiguous. It distinguishes itself from siblings like 'get_script_project_tool' (singular retrieval) and 'list_script_processes_tool' (different resource type), avoiding tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., authentication), differentiate from similar tools like 'list_spreadsheets_tool' or 'list_drive_items_tool', or specify scenarios for its use, leaving the agent without contextual direction.

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. While it mentions the tool lists spreadsheets with optional filtering and pagination, it doesn't address important behavioral aspects like authentication requirements (though implied by the user_google_email parameter), rate limits, whether it's read-only, what happens with invalid queries, or the format of returned results.

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

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

The description is appropriately sized with a clear purpose statement followed by parameter explanations. The structure is front-loaded with the main functionality, though the Args section could be more integrated with the main description rather than appearing as a separate block.

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 that an output schema exists (which handles return values), the description covers the basic functionality adequately. However, for a tool with 3 parameters, 0% schema description coverage, and no annotations, it should provide more behavioral context about authentication, error handling, and how it differs from similar sibling tools.

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

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

The description provides basic parameter information in the Args section, explaining what each parameter represents. However, with 0% schema description coverage and 3 parameters, the description doesn't fully compensate - it lacks details about parameter formats (e.g., email validation), query syntax, or page_size constraints. The baseline is 3 since the Args section adds some value beyond the bare 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 resource ('Google Sheets spreadsheets in Drive'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from similar sibling tools like 'list_drive_items_tool' or 'search_drive_files_tool', which could also list files including spreadsheets.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like 'list_drive_items_tool' and 'search_drive_files_tool' available, there's no indication whether this tool is specifically for spreadsheets only, whether it has different filtering capabilities, or when one should be preferred over another.

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 clarifies that versions are 'immutable snapshots,' indicating read-only behavior, and mentions how they're created, which adds useful context. However, it doesn't disclose other behavioral traits like pagination, rate limits, authentication needs, or error conditions that would be important for a list operation.

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

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

The description is well-structured and front-loaded with the core purpose, followed by explanatory context and parameter details. Every sentence adds value: the first states what it does, the second explains versions, the third tells when they're created, and the Args section clarifies the parameter. No wasted words.

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 low complexity (1 parameter), no annotations, but with an output schema present, the description is reasonably complete. It explains the purpose, parameter, and context of versions. The output schema will handle return values, so the description doesn't need to cover those. However, it could benefit from more behavioral details given the lack of annotations.

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 includes an 'Args' section that explains the single parameter ('script_id: The script project ID'), adding meaning beyond the schema's 0% coverage. This fully compensates for the lack of schema descriptions, making the parameter purpose clear. The baseline would be lower without this, but the explicit parameter explanation earns a high score.

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

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

The description clearly states the specific action ('List all versions') and resource ('of a script project'), with additional context about what versions are ('immutable snapshots of your script code'). It distinguishes from sibling tools like get_version_tool (singular) and create_version_tool, making the scope explicit.

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

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

The description provides clear context for when to use this tool by explaining when versions are created ('when you deploy or explicitly create a version'), which helps the agent understand the tool's purpose. However, it doesn't explicitly state when NOT to use it or name specific alternatives among siblings, though the distinction from get_version_tool is implied.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool modifies text, implying a write operation, but lacks details on permissions required, error handling, or side effects (e.g., whether changes are reversible). The description doesn't mention the output schema, leaving the agent uncertain about the response format. This is a significant gap for a mutation tool.

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

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

The description is well-structured and appropriately sized. It starts with a clear purpose statement, followed by a bullet-point list of parameters with brief explanations. There's no wasted text, and the information is front-loaded. A perfect score would require slightly more detail on usage or behavior, but it's efficient as-is.

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 (5 parameters, mutation operation, no annotations) and the presence of an output schema, the description is moderately complete. It explains parameters well but lacks behavioral context (e.g., permissions, errors) and doesn't reference the output schema. For a mutation tool with no annotations, it should do more to guide the agent on safe and 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?

The description adds substantial meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose: 'user_google_email: The user's Google email address', 'document_id: The document ID', 'text: Text to insert (or replace with)', 'index: Position to insert text (default: 1, start of document)', and 'replace_text: If provided, find and replace this text with 'text''. This clarifies how parameters interact (e.g., 'replace_text' triggers replacement instead of insertion). However, it doesn't cover all edge cases, such as invalid indices or empty strings.

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: 'Modify text in a Google Doc.' It specifies the verb ('modify') and resource ('text in a Google Doc'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'append_doc_text_tool' or 'get_doc_content_tool', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'append_doc_text_tool' for appending text or 'search_docs_tool' for finding documents, nor does it specify prerequisites such as authentication or document access. This leaves the agent without context for tool selection.

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 effectively describes the core behavior (adding/removing labels) and provides practical examples, but lacks details on permissions, error handling, or side effects (e.g., what happens if conflicting labels are added/removed). It doesn't contradict annotations, but could be more comprehensive given the mutation nature of the 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 well-structured and front-loaded with the core purpose, followed by helpful reference information (common label IDs), parameter details, and practical examples. Every section earns its place by providing essential guidance without redundancy, making it efficient and easy to scan.

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 (mutation with 4 parameters), no annotations, and an output schema (which reduces need to describe return values), the description is quite complete. It covers purpose, parameters with semantics, and usage examples. A minor gap is the lack of explicit behavioral constraints (e.g., rate limits, auth requirements), but overall it provides strong contextual 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?

The schema description coverage is 0%, so the description must fully compensate. It does so excellently by listing all 4 parameters with clear explanations, common label IDs with descriptions, and practical examples showing how to use 'add_labels' and 'remove_labels'. This adds significant meaning beyond the bare schema, making parameter usage intuitive.

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

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

The description clearly states the specific action ('Modify labels') on a specific resource ('Gmail message'), distinguishing it from sibling tools like 'get_gmail_message_tool' or 'search_gmail_messages_tool'. It uses precise language that immediately communicates the tool's function without ambiguity.

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

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

The description provides clear context for when to use this tool through examples (e.g., 'Archive: remove_labels=["INBOX"]', 'Mark read: remove_labels=["UNREAD"]'), which implicitly guides usage. However, it doesn't explicitly state when NOT to use it or mention alternatives among siblings, though the examples cover 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 are provided, so the description carries the full burden. It states the tool removes permissions, implying a destructive mutation, but doesn't disclose critical behavioral traits like whether this requires admin permissions, if changes are reversible, potential side effects (e.g., access loss), or rate limits. The description is minimal and lacks necessary context for safe use.

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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by a structured 'Args' section. Every sentence earns its place by providing essential information without redundancy. It's efficient and well-organized for quick understanding.

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 (a destructive mutation with 3 parameters), no annotations, and an output schema (which reduces the need to describe return values), the description is partially complete. It covers parameters well but lacks behavioral context like permissions needed or consequences. For a mutation tool, this is a moderate gap, making it adequate but with clear room for improvement.

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 includes an 'Args' section that explains each parameter: 'user_google_email: The user's Google email address', 'file_id: The file or folder ID', and 'permission_id: The permission ID to remove (from list_drive_permissions)'. This adds significant meaning beyond the input schema, which has 0% description coverage and only specifies types. The parameter semantics are clear and practical, compensating well for the schema gap.

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

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

The description clearly states the tool's purpose: 'Remove a permission from a file or folder.' This specifies the verb ('remove') and resource ('permission from a file or folder'), making it unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'share_drive_file_tool' or 'list_drive_permissions_tool', which would require mentioning it's specifically for revocation rather than granting or listing.

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

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

The description implies usage by referencing 'permission_id: The permission ID to remove (from list_drive_permissions)', suggesting this tool should be used after listing permissions. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'share_drive_file_tool' for adding permissions, or clarify prerequisites such as needing appropriate access rights.

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 mentions the prerequisite deployment requirement and the dev_mode behavior (latest vs deployed code), which are valuable. However, it doesn't cover important aspects like authentication needs, rate limits, error handling, or what the execution entails (e.g., whether it's synchronous/asynchronous, timeout behavior).

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

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

The description is efficiently structured with a clear purpose statement upfront, followed by a prerequisite note, and then parameter explanations. Every sentence serves a distinct purpose with zero wasted words, making it easy to parse quickly.

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

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

For a tool that executes arbitrary code (a complex operation), the description covers the core purpose, prerequisites, and parameters well. The presence of an output schema means return values don't need explanation. However, given the potential risks of code execution and no annotations, more behavioral context about safety, permissions, or execution limits would strengthen completeness.

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?

Given 0% schema description coverage, the description fully compensates by explaining all 4 parameters: script_id ('The script project ID'), function_name ('Name of function to execute'), parameters ('Optional list of parameters to pass to the function'), and dev_mode ('If True, run latest code; if False, run deployed version'). This adds crucial meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Execute a function in a deployed script') and identifies the resource (Apps Script functions). It distinguishes this tool from siblings like create_script_project_tool or get_script_content_tool by focusing on execution rather than creation or retrieval.

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

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

The description provides clear context for when to use this tool ('Requires the script to be deployed as "API Executable"') and references setup instructions. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools for similar operations.

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

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

No annotations are provided, so the description carries the full burden. It states the tool searches by name and returns a paginated result (implied by 'page_size'), but lacks details on permissions needed (e.g., whether the user_google_email must have access), rate limits, error handling, or what the output contains (though an output schema exists). For a search tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a structured 'Args:' section listing parameters with brief explanations. There's minimal waste, though the structure could be more integrated (e.g., embedding parameter details in prose). Every sentence adds value.

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

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

Given the tool's moderate complexity (search with pagination), no annotations, and an output schema (which handles return values), the description is partially complete. It covers the basic purpose and parameters but lacks behavioral context (e.g., authentication needs, search scope limitations) and doesn't leverage sibling tool names for differentiation. It's adequate but has clear gaps in guidance and transparency.

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 by explaining each parameter: 'user_google_email' as the user's Google email address, 'query' as a search query string, and 'page_size' as the maximum number of docs to return with a default. However, it doesn't clarify format constraints (e.g., email validation) or query syntax (e.g., wildcards). The description partially compensates but not fully for the coverage gap.

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

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

The description clearly states the tool's purpose: 'Search for Google Docs by name.' This specifies the verb (search), resource (Google Docs), and scope (by name). However, it doesn't explicitly differentiate from sibling tools like 'search_drive_files_tool' or 'list_drive_items_tool', which might offer similar functionality for different resources or scopes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_drive_files_tool' (which might search broader file types) or 'list_drive_items_tool' (which might list without searching), nor does it specify prerequisites (e.g., authentication status) or exclusions. Usage is implied only by the tool 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?

With no annotations provided, the description carries the full burden. It discloses that it searches files and folders, supports query operators, and returns a maximum number of files (with pagination implied by 'page_size'). However, it does not mention authentication needs, rate limits, error handling, or whether the search is scoped to the user's Drive. It adds some behavioral context but leaves gaps for a search 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 appropriately sized and front-loaded with the core purpose. The 'Args:' section efficiently documents parameters with examples. However, the query examples could be slightly more concise, and the structure is clear but not perfectly streamlined.

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

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

Given the tool's moderate complexity (search with query operators), no annotations, and the presence of an output schema (which handles return values), the description is mostly complete. It covers purpose, parameters, and basic behavior. However, it lacks details on authentication, error cases, or result format, which could be useful despite the output schema.

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

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

Schema description coverage is 0%, so the description must fully compensate. It provides detailed semantics for all three parameters: 'user_google_email' specifies the user's Google email, 'query' explains search query string with examples of Drive operators, and 'page_size' defines the maximum number of files and default value. This adds significant meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Search for files and folders') and resource ('in Google Drive'), distinguishing it from sibling tools like 'list_drive_items_tool' (which likely lists without search) and 'search_docs_tool' (which searches Docs specifically). It provides a precise verb+resource combination that is not tautological.

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 searching Drive files/folders with query operators, but does not explicitly state when to use this tool versus alternatives like 'list_drive_items_tool' or 'search_docs_tool'. It provides context for search functionality but lacks explicit guidance on exclusions or comparisons to 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 carries the full burden of behavioral disclosure. It mentions the action ('search') and a default value for 'max_results,' but fails to describe key behaviors such as authentication requirements, rate limits, error handling, pagination, or the format of returned results. The presence of an output schema mitigates some gaps, but the description lacks essential operational context for a tool that likely interacts with external APIs.

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 appropriately sized and front-loaded, with the core purpose stated first followed by parameter details in a clear 'Args:' section. Every sentence adds value, such as the query example, and there is no redundant or verbose content. However, the structure could be slightly improved by integrating usage guidelines or behavioral notes more seamlessly.

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

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

Given the tool's moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameter semantics adequately and the output schema will handle return values, but it lacks critical behavioral details like authentication needs, rate limits, and error conditions. For a search tool interacting with Gmail, this omission leaves significant gaps in understanding how to use it effectively.

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

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

The description adds meaningful context for all three parameters beyond the input schema, which has 0% description coverage. It clarifies that 'user_google_email' is 'The user's Google email address,' 'query' is a 'Gmail search query' with an example, and 'max_results' has a default of 10. This compensates well for the schema's lack of descriptions, though it does not detail constraints like email format validation or query syntax beyond the example.

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 as 'Search for Gmail messages matching a query,' which includes a specific verb ('search') and resource ('Gmail messages'). It distinguishes itself from sibling tools like 'get_gmail_message_tool' (which retrieves a single message) and 'send_gmail_message_tool' (which sends messages), but does not explicitly differentiate from other search tools like 'search_docs_tool' or 'search_drive_files_tool' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., authentication status), compare it to similar tools like 'get_gmail_message_tool' for single-message retrieval, or specify scenarios where it is most appropriate. The only implied usage is for searching Gmail messages, but this is redundant with the purpose statement.

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. While 'Send' implies a write operation, it doesn't disclose critical behaviors: whether this requires specific Gmail permissions, if there are rate limits, whether the email is sent immediately or queued, or what happens on failure. The description lacks essential context 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 reasonably concise with a clear purpose statement followed by parameter details. However, the parameter explanations are somewhat minimal, and the structure could be improved by grouping related parameters or adding usage examples. It's functional but not optimally organized.

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 this is a mutation tool with 7 parameters, 0% schema description coverage, no annotations, but with an output schema, the description is moderately complete. It covers basic purpose and parameters but lacks behavioral context and usage guidance. The output schema existence means return values don't need explanation, but other gaps remain significant.

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 provides a parameter list with brief explanations that add meaningful context beyond the schema's 0% coverage. It clarifies that 'to' accepts comma-separated addresses, 'cc' and 'bcc' are optional, and 'html' determines body format. This compensates well for the schema's lack of descriptions, though it doesn't cover all parameter nuances like email format validation.

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 ('Send') and resource ('a Gmail message'), making the purpose immediately understandable. It distinguishes from sibling tools like 'get_gmail_message_tool' and 'search_gmail_messages_tool' by focusing on sending rather than retrieving. However, it doesn't explicitly contrast with other email-related tools since none exist in the sibling 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 versus alternatives. It doesn't mention prerequisites like authentication, nor does it specify scenarios where this tool is appropriate versus other communication methods. The sibling tools include various Google services, but no explicit comparison is made.

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 action is to 'share' which implies a write/mutation operation, but doesn't mention important behavioral aspects like whether this requires specific permissions, if it's reversible, potential rate limits, or what happens on failure. The description is too minimal for a mutation tool.

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

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

The description is perfectly structured and concise. The first sentence states the core purpose, followed by a well-organized Args section that documents each parameter clearly without unnecessary elaboration. Every sentence earns its place.

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

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

For a mutation tool with no annotations, the description is incomplete despite having an output schema. It covers parameters well but lacks critical behavioral context about permissions, side effects, and error conditions. The presence of an output schema helps, but doesn't fully compensate for the missing behavioral transparency.

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 provides excellent parameter clarification. It explains all 5 parameters with clear semantics: what each parameter represents, the valid values for 'role', and default behavior for 'send_notification'. This significantly compensates for the lack of schema documentation.

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

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

The description clearly states the action ('Share') and resource ('a file or folder with a user'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_drive_permissions_tool' or 'remove_drive_permission_tool', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_drive_permissions_tool' or 'remove_drive_permission_tool'. It also lacks information about prerequisites (e.g., authentication requirements) or constraints (e.g., file ownership).

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 clearly explains that the tool returns an authorization URL that must be opened in a browser, which is crucial behavioral information. However, it doesn't mention potential authentication scopes, error conditions, or timeout behavior that might be relevant for this type of authentication flow 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 perfectly concise with three sentences that each serve a distinct purpose: stating the tool's function, describing what it returns, and providing the next step. There is no wasted language or redundancy.

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

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

Given that this is an authentication tool with 0 parameters, no annotations, but has an output schema, the description provides good context about what the tool does and the workflow. However, it could benefit from mentioning typical use cases or prerequisites (like needing to set up OAuth credentials first) for a more 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?

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, which is correct for this tool configuration.

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

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

The description clearly states the specific action ('Start Google OAuth authentication flow') and the resource involved (authentication flow). It distinguishes itself from sibling tools by focusing on initiating authentication rather than performing operations on Google resources like documents, sheets, or events.

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

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

The description explicitly states when to use this tool ('Start Google OAuth authentication flow') and provides clear guidance on what to do next ('After authorizing, call complete_google_auth with the redirect URL'), naming the specific alternative tool for the next step in the 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 provided, the description carries the full burden of behavioral disclosure. It mentions the action is 'recoverable,' which is useful context about the tool's effect. However, it lacks details on permissions needed, rate limits, error conditions, or what the output might contain. For a mutation tool with zero annotation coverage, this 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a brief Args section. There's no wasted text, and the structure is logical. However, the Args section could be integrated more seamlessly, and it's slightly verbose for such a simple tool.

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

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

Given the tool's moderate complexity (a mutation with 2 parameters) and the presence of an output schema (which reduces the need to describe return values), the description is somewhat complete. It covers the basic action and parameters but lacks behavioral details like error handling or permissions. With no annotations and low schema coverage, it should do more to be fully adequate.

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 schema provides no parameter details. The description adds basic semantics for both parameters: 'user_google_email' is described as 'The user's Google email address' and 'file_id' as 'The file ID to trash.' This clarifies their roles but doesn't provide format examples, validation rules, or sourcing guidance. It partially compensates for the schema gap but not 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 the tool's purpose: 'Move a file to trash in Google Drive (recoverable).' It specifies the verb ('move'), resource ('file'), and location ('trash'), and distinguishes it from siblings like delete_drive_file_tool by noting recoverability. However, it doesn't explicitly differentiate from other trash-related tools (none listed), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over delete_drive_file_tool (which likely permanently deletes) or other file management tools, nor does it specify prerequisites like authentication or permissions. The only implied usage is for trashing files, but no explicit context 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 provided, the description carries full burden for behavioral disclosure. While 'Update' implies a mutation operation, the description doesn't disclose important behavioral traits: whether this requires specific permissions, if changes are reversible, what happens to other deployment settings not mentioned, rate limits, or error conditions. It mentions only one updatable field (description) without clarifying if this is the only field that can be updated.

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 appropriately concise with two sentences: a clear purpose statement followed by parameter explanations. The Args section is well-structured and easy to parse. Every sentence adds value, though the parameter explanations could be slightly more detailed given the 0% schema coverage.

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 that an output schema exists, the description doesn't need to explain return values. However, for a mutation tool with no annotations, 0% schema description coverage, and 3 parameters, the description should provide more behavioral context about what 'update' entails, potential side effects, and usage constraints. The current description is minimally complete but leaves significant gaps.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds basic semantic meaning for all three parameters (script_id, deployment_id, description), explaining what each represents. However, it doesn't provide format details, constraints, or examples. For a tool with 3 parameters and 0% schema coverage, this is minimal but adequate compensation.

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 ('Update') and resource ('existing deployment configuration'), making the purpose immediately understandable. It distinguishes from sibling tools like 'create_deployment_tool' and 'delete_deployment_tool' by specifying it updates existing configurations rather than creating or deleting them. However, it doesn't specify what aspects of the deployment configuration can be updated beyond the description field.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing deployment), when-not-to-use scenarios, or how it differs from similar tools like 'update_script_content_tool' or 'update_event_tool'. The agent must infer usage from the tool name and description 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 are provided, so the description carries the full burden of behavioral disclosure. It states this is an update operation but doesn't mention important behavioral aspects: what permissions are required, whether changes are reversible, how conflicts are handled, rate limits, or what the response looks like. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is well-structured and appropriately sized. The first sentence states the core purpose, followed by a clear 'Args:' section with bullet-point parameter explanations. Every sentence adds value, though the 'all_day' explanation could be slightly clearer. The structure helps users quickly understand both what the tool does and how to use it.

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 (10 parameters, mutation operation) and the presence of an output schema (which reduces need to describe return values), the description is moderately complete. It covers all parameters but lacks behavioral context (permissions, side effects) and usage guidance. For a tool with no annotations and significant parameters, it should provide more context about when and how to use it effectively.

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 provides substantial value by explaining all 10 parameters in the 'Args' section. It clarifies semantics like 'calendar_id (default: "primary")', 'start_time in ISO format', 'attendees as comma-separated list', and the conditional logic for 'all_day'. This compensates well for the schema's lack of descriptions, though some format details (like exact ISO format) could be more precise.

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: 'Update an existing calendar event.' It specifies the verb ('update') and resource ('calendar event'), making the function immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_event_tool' or 'delete_event_tool' beyond the obvious verb difference, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. While the name 'update_event_tool' implies it's for modifying existing events (versus 'create_event_tool' for new ones), the description doesn't mention prerequisites, constraints, or sibling relationships. There's no explicit when/when-not usage advice or references to other tools.

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

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

With no annotations provided, the description carries full burden but only states the basic action ('Update or create files'). It lacks critical behavioral details: whether this overwrites existing files, requires specific permissions, handles errors, or affects script execution. For a mutation tool, this leaves significant gaps in understanding its effects and constraints.

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 well-structured with a clear purpose statement, labeled arguments, and a helpful example. Every sentence adds value, and it's front-loaded with the core action. The example is concise but illustrative, though the formatting could be slightly more streamlined.

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 2 parameters with 0% schema coverage and an output schema present, the description adequately covers parameter semantics but lacks behavioral context for a mutation tool. It doesn't explain what 'update or create' entails operationally or address potential side effects. The output schema reduces the need to describe returns, but overall completeness is moderate due to missing usage and transparency details.

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

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

Schema description coverage is 0%, so the description must compensate. It effectively explains both parameters: 'script_id' as the project ID and 'files' as a list with detailed structure (name, type, source). The example clarifies the 'files' format, adding substantial meaning beyond the bare schema. However, it doesn't specify allowed file types beyond the example or constraints on 'script_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 ('Update or create files') and resource ('in a script project'), making the purpose immediately understandable. It distinguishes from siblings like 'create_script_project_tool' by focusing on file content rather than project creation, though it doesn't explicitly contrast with 'get_script_content_tool' or 'create_version_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?

No guidance is provided about when to use this tool versus alternatives like 'create_version_tool' for versioning or 'get_script_content_tool' for reading. The description assumes the user knows they need to modify script files, offering no context about prerequisites, typical workflows, or exclusion criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is an update operation but doesn't mention whether it overwrites existing values, requires specific permissions, has rate limits, or what happens on errors. The description lacks crucial behavioral context 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 efficiently structured with a clear opening statement followed by a well-organized parameter list. Every sentence adds value, and there's no redundant or unnecessary 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 that this is a mutation tool with no annotations, 5 parameters, and an output schema exists, the description does an adequate job explaining parameters but lacks critical behavioral context like permissions, error handling, and sibling tool differentiation. The presence of an output schema helps, but the description should do more for a tool that modifies data.

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 provides clear explanations for all 5 parameters, including examples for 'range' and 'values', and clarifies the 'value_input' enum options. This adds significant value beyond the bare schema, though it doesn't fully explain data format constraints for 'values'.

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 'Update' and resource 'values in a Google Sheet', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'append_sheet_values_tool' or 'modify_doc_text_tool', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'append_sheet_values_tool' or 'get_sheet_values_tool'. There's no mention of prerequisites, such as authentication or permissions, which are critical for Google Sheets operations.

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