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

Discloses the key side effect: 'replaces any existing validation on the range.' Without annotations, this is critical. Could mention more edge cases or performance, but sufficient.

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

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

Three concise sentences: first states purpose, second adds side effect, third provides alternatives and auth requirement. No unnecessary words, 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?

Covers purpose, side effect, alternatives, and auth. Output schema exists, so return values are handled. Minor gaps in edge-case behavior, but overall complete for usage.

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

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

Schema description coverage is 100%, so parameters are well-documented. The description adds only a high-level summary (dropdowns, bounds, formulas), not enhancing individual parameter meaning.

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

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

The description clearly states the verb 'Apply' and the resource 'data-validation rule to a range', with examples (dropdowns, bounds, formulas). It distinguishes itself from sibling tools like manage_conditional_formatting and protect_sheet_range.

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

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

Explicitly tells when to use this tool (for data validation) and when not (conditional formatting -> manage_conditional_formatting, cell protection -> protect_sheet_range). Also notes the required OAuth scope.

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

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

No annotations are provided, so the description carries the full burden. It discloses the OAuth write scope, but does not mention potential side effects (e.g., overwriting existing named ranges with the same name, behavior on invalid range, or scope of effect beyond the spreadsheet). The description is adequate for a simple creation tool but could be more transparent about conflict resolution.

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 and provides examples in a well-structured manner. However, it is slightly verbose, including details like the Data > Named ranges sidebar and autocomplete behavior. Every sentence adds value, but some conciseness is sacrificed for thoroughness.

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 presence of an output schema (as per context signals), the description need not explain return values. It covers the concept, usage in formulas, and OAuth requirement. However, it lacks information on error handling (e.g., duplicate name or invalid range) and does not reference any prerequisites beyond auth. Overall, it provides solid context but has minor 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 75%, and the schema itself provides detailed descriptions for parameters like 'name' and 'range_name'. The tool description adds no new parameter semantics beyond the schema; it provides usage context (e.g., how to use named ranges in formulas) but does not elaborate on the parameters themselves. Hence, it meets the baseline for the given coverage.

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

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

The description clearly states the tool's purpose: 'Define a named range that formulas and scripts can reference by name.' It provides specific examples and explains the benefit of readability and reference stability. This distinguishes it from sibling sheet tools like 'add_sheet_data_validation' or 'format_sheet_range'.

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 explains when to use the tool (to make formulas more readable, allow cell movement without breaking references) and notes the required OAuth scope. However, it does not explicitly mention when not to use it or compare to alternatives like direct A1 references. The context is clear but lacks exclusionary guidance.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: mutation, auto-extending range, automatic type conversion (bool, number, formula), and OAuth scope requirement. It lacks explicit error conditions or idempotency, but covers essential traits well.

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 with two short paragraphs. It front-loads the purpose and uses clear, non-redundant language. Every sentence adds value with no fluff.

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 complexity (mutation with typing) and presence of an output schema, the description covers purpose, side effects, typing, alternatives, and auth scope. It omits error handling and return value details, but is largely complete for agent 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?

Input schema coverage is 100%, so baseline is 3. The description does not add significant meaning beyond the schema. It mentions auto-extending range related to values, but no additional parameter-level details.

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 'Append rows to a structured Sheets table, auto-extending its range.' It uses a specific verb+resource and explicitly distinguishes from the sibling tool modify_sheet_values for plain range writes.

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 (for structured table appends) and when not to (use modify_sheet_values for plain range writes). It also mentions prerequisites like table_id from list_sheet_tables.

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

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

No annotations are provided, so the description bears full responsibility. It discloses the tool modifies the document (converts text to numbered lists) and states idempotency. However, it omits details about permissions required, effect on existing formatting, or behavior with non-standard prefixes.

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

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

The description is a single sentence plus an idempotency note, which is concise and front-loaded. It avoids unnecessary words but could be slightly more structured with separate sections for parameters and behavior.

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 modifies documents and has an output schema (unspecified), the description provides enough context for basic usage but lacks details on handling edge cases like existing numbered lists, mixed content, or error scenarios. The mention of 'prompt paragraphs' and 'sub-bullet lists' adds useful specificity.

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

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

The description does not explain any parameters. The schema covers 75% of parameters with descriptions, but user_google_email lacks a description. The tool description adds no value beyond the schema, failing to clarify the required email parameter or the effect of strip_plain_text.

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

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

The description clearly states the tool converts plain-text 'N. ' step prefixes into a real numbered list with continuous numbering. It specifies the resource (Google Doc or specific tab) and distinguishes this from sibling tools like modify_doc_text or update_paragraph_style.

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 notes idempotency and safety for re-running, providing some guidance. However, it does not explicitly state when to use this tool over alternatives (e.g., when to use apply_continuous_numbering vs modify_doc_text for list formatting).

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. It discloses that the tool mutates label sets on every message and notes the Gmail API limit not enforced. While it doesn't detail error handling or atomicity, it provides sufficient 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 three compact sentences: purpose, side effects and API detail, sibling tool and auth. Every sentence adds value with no redundancy 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 the presence of an output schema, the description need not cover return values. It adequately covers purpose, behavioral traits, limits, alternatives, and auth. Minor gaps like error handling or batch size enforcement are acceptable for a batch 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?

Input schema has 100% coverage, with each parameter clearly described (e.g., message_ids from search, label IDs with system/user distinction). The description adds no additional parameter details beyond the schema, so baseline score applied.

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

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

The description explicitly states the tool adds or removes labels on many Gmail messages, clearly defining the action and resource. It also distinguishes from the sibling tool by noting that single messages should use modify_gmail_message_labels.

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

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

The description provides explicit guidance on when to use this tool (batch operations) and when not to (single messages, directing users to modify_gmail_message_labels). It also mentions the Gmail API limit of 1000 IDs and the required OAuth scope, helping agents select correctly.

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 covers atomicity (single atomic batch), low-level nature, and includes caveats about index calculation errors and the workflow to avoid them. It does not explicitly state error handling or return values, but the presence of an output schema mitigates this. Overall, good transparency.

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

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

The description is relatively long but well-structured with clear sections (RECOMMENDED WORKFLOW, PHASE 1, etc.). It front-loads the purpose and then provides detailed guidelines. Every sentence adds value, though it could be slightly more concise.

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

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

Given the complexity of the tool (many operation types) and the presence of an output schema, the description is fairly complete. It covers main workflows, alternatives, and common pitfalls. It could include more on error handling or specific edge cases, but overall it's thorough.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value beyond the schema by explaining the recommended use of end_of_segment, the purpose of tab_id and segment_id, and the overall workflow. It provides context that helps the agent use parameters correctly.

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

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

The description clearly states it executes multiple low-level document operations in a single atomic batch update. It specifies the verb (executes), resource (low-level document operations), and distinguishes from siblings by mentioning alternatives like update_doc_headers_footers.

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 and when to prefer alternatives. It says 'For normal header/footer text, prefer update_doc_headers_footers' and 'Only use create_header_footer here for advanced section-break layouts.' It also includes a recommended workflow for building documents in phases, which is highly actionable.

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

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

Discloses atomicity (partial failure rolls back entire batch), requires forms OAuth scope, and implies destructive nature (modification). No annotations are provided, so the description carries the full burden. It could be improved by noting idempotency or rate limits, but it is adequate and accurate.

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

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

Two compact paragraphs with no wasted words. The first sentence captures the core purpose. Details are organized logically: atomicity, usage order, alternatives, and auth scope.

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

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

Given the complexity of batch update (multiple request types, atomicity) and the presence of an output schema, the description covers all essential behavioral and contextual aspects: what it does, prerequisites, alternatives, scope requirements, and atomicity behavior. No 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 coverage is 100%, so baseline is 3. The description adds value by explaining that each request object must have exactly one key (createItem, updateItem, etc.) and provides a link to full schemas. It also clarifies form_id source (edit URL) and user_google_email (authenticated account), going beyond the schema.

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

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

The description clearly states it applies a batch of Forms API edit requests atomically, listing specific operations (add/update/delete questions, reorder, update info, toggle quiz mode). It distinguishes itself from sibling tools like set_publish_settings and get_form by positioning itself as the primary way to modify a form after 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?

Explicitly advises to use get_form first to discover existing itemIds/questionIds, and for publish settings to use set_publish_settings. This provides clear when-to-use and when-not-to-use guidance, with specific alternatives named.

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

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

Despite no annotations, the description discloses atomic execution with rollback on partial failure and OAuth scope requirement. It could mention potential destructiveness, but the core behavioral traits are covered.

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

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

Three concise sentences that front-load purpose, then add context and behavioral details. No unnecessary 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?

For a low-level batch API, the description covers purpose, usage, atomicity, and authentication. The presence of an output schema likely covers return values, making this complete.

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

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

Schema coverage is 100% with clear parameter descriptions. The description does not add additional meaning beyond the schema, earning baseline 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 tool applies a batch of Slides API edit requests atomically. It explicitly contrasts with high-level helpers, distinguishing it as the low-level escape hatch.

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 (for operations not covered by high-level helpers) and notes atomicity and rollback behavior, providing clear guidelines.

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

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

Discloses that it checks first match, requires drive.readonly scope, and is a helper for embedding. However, does not explicitly state output format or error behavior (e.g., if no file found). Still good for a simple tool with no annotations.

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?

Concise, well-structured with main action first, then context and alternatives. Every sentence adds value. No redundancy.

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

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

Given the tool's simplicity and presence of an output schema, the description covers purpose, usage context, sibling differentiation, and OAuth requirement. It is self-contained and complete.

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

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

Schema coverage is 100% so baseline is 3. Description adds context about filename search and multiple matches but does not elaborate on the email parameter. Sufficient overlap with 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?

Clear verb 'Search' and 'report' with specific resource 'whether file is publicly linked'. Differentiates from sibling 'get_drive_file_permissions' for specific files. Aligns with Google Docs embedding use case.

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

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

Explicitly states when to use (before insert_doc_image), limitation (checks first if multiple matches), and alternative for specific file (get_drive_file_permissions). Also mentions required OAuth scope.

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

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

No annotations provided, so description bears full burden. It discloses side effects (creates new file owned by caller, preserves content/formatting) and required scope. Could be more specific about permission handling or limits, but sufficiently transparent for typical 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?

Description is concise (three sentences) but packed with essential info: action, side effects, usage guidance, and scope. Front-loaded with verb and resource, no unnecessary 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 output schema exists (handles return values), description covers all key aspects: purpose, side effects, alternatives, and prerequisites. No gaps for effective tool invocation.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds minimal extra meaning beyond schema (e.g., default name pattern, parent folder default 'root'). No in-depth parameter elaboration.

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

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

The description clearly states the action ('Duplicate a Drive file'), specifies the resource (Drive file including Google Docs/Sheets/Slides), and distinguishes from sibling tool 'copy_drive_folder' by explicitly mentioning folder handling.

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

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

Provides explicit when-to-use guidance: for folders, use copy_drive_folder; for Google Docs, describes a standard pattern (copy then edit). Also mentions required OAuth scope, giving clear instructions for invocation.

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. It discloses recursive copy and sequential processing to avoid rate-limit errors, but fails to mention permissions handling, overwrite behavior, or file size limits. This is adequate but has notable gaps.

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

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

The description is two sentences: the first succinctly defines the action, the second adds key details (tree walk, sequential). No redundant or unnecessary information. Perfectly front-loaded and concise.

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

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

Given the tool's complexity (4 params, no annotations, output schema exists), the description covers recursive nature and sequential processing but omits error handling, permission requirements, and what happens on naming conflicts. Sufficient but not fully comprehensive.

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

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

Schema description coverage is 75%, and the existing schema descriptions are clear. The tool description does not add extra meaning beyond the schema for parameters; e.g., 'user_google_email' lacks description in both. Baseline of 3 is appropriate.

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

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

The description clearly states the tool recursively copies a Drive folder and all its contents to a new location. It explicitly mentions 'sequential' behavior to avoid rate-limit errors, distinguishing it from sibling tools like copy_drive_file (single file) and create_drive_folder (empty folder).

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

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

The description implies the tool is for copying entire folder trees but does not explicitly state when to use it over alternatives like copy_drive_file for single files or create_drive_folder for empty folders. No when-not-to-use guidance is provided, which is a gap given the large list of sibling 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?

Discloses side effects (creates calendar, adds to list) and required OAuth scope. With no annotations, this is helpful, though it could mention limits or error handling.

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

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

Four short sentences, front-loaded with purpose, followed by side effects, guidance, and scope. No unnecessary 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?

With no annotations, the description covers purpose, side effects, scope, and returns (implied calendar_id). Missing output schema details but adequate 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 already covers all parameters with detailed descriptions (100% coverage). The description adds no extra parameter-specific meaning beyond what schema provides.

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

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

Description clearly states the tool creates a secondary calendar for the user, with specific verb and resource. It differentiates from siblings like list_calendars (listing) and manage_event (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?

Explicitly tells when to use this tool (creating a calendar) and when not to (use manage_event for events, web UI/ACL for sharing), providing clear 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?

Details document body indexing (starts at 1, empty doc length 2), markdown parsing behavior, and sequential workflow. With no annotations, description effectively discloses structural and behavioral traits.

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

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

Three paragraphs with no wasted sentences. Front-loaded with main purpose, then structural details, then workflow. Efficiently 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 output schema exists, description need not explain return values. Covers creation, structure, and complete workflow guidance with sibling tool references. Sufficient for an agent to use correctly.

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

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

Input schema has 100% coverage, so baseline 3. Description adds marginal context about document indexing but largely restates schema info. No significant additional parameter detail.

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?

Clearly states it creates a new Google Doc with optional initial content. Specifically names the resource and action, distinguishing it from siblings like batch_update_doc and insert_doc_markdown.

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

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

Provides explicit after-creation workflow: use batch_update_doc for rich content and inspect_doc_structure before formatting. Implicitly differentiates when to use this vs other tools, though no direct 'when not to use' 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?

No annotations provided, so description carries full burden. It mentions side effects ('creates a new Drive file') and the required OAuth scope ('drive.file'), adding useful behavioral context beyond the schema.

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

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

Four sentences, front-loaded with core purpose. Each sentence adds distinct value: purpose, side effects, alternatives, and auth requirement. Minor redundancy but overall 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?

Covers core action, alternatives, and auth requirement. With good schema coverage and output schema, description is nearly complete. Could mention mutual exclusivity of content and fileUrl, but schema already does.

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

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

Schema coverage is 100%, so baseline is 3. Description only hints at parameters ('from content, a URL, or a local path') without adding significant meaning beyond the schema's detailed 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 tool uploads a file to Drive from content, URL, or local path, and distinguishes itself from sibling tools like import_to_google_doc and create_doc for specific use cases.

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

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

Explicitly provides when to use alternatives: 'To convert source files... use import_to_google_doc instead. For a brand-new empty Google Doc/Sheet/Slide use create_doc/create_spreadsheet/create_presentation.' Also notes the required OAuth scope.

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

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

No annotations provided, but description discloses ownership side effects, relationship to create_drive_file, and OAuth scope requirement. Does not mention error conditions or rate limits, but sufficient for a creation tool.

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

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

Three concise sentences, front-loaded with the primary action. Every sentence adds necessary context 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?

Explains purpose, side effects, and next steps. Implies return value (ID) but does not detail the output schema. Slightly incomplete for a tool with output schema.

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

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

Schema coverage is 100%, so the description adds value by explaining ownership implications of parent_folder_id and clarifying that forward slashes in folder_name are literal. This goes beyond the schema.

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

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

The description clearly states 'Create a new folder in Drive (or inside a shared drive)', specifying the verb and resource. It distinguishes from sibling tools like create_drive_file by mentioning folder creation and shared drive context.

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

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

Describes side effects (ownership) and explicitly directs to use create_drive_file for uploading files, indicating when to use this tool vs alternatives. Mentions required OAuth scope but lacks explicit 'when not to use' guidance.

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

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

Discloses side effects (creates empty form owned by user) and required OAuth scope. With no annotations, the description carries the transparency burden and does it well, though it could mention failure modes or response structure.

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

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

Three concise sentences: purpose, side effects/alternatives, and scope. No unnecessary words, well 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 is a creation action with an output schema, the description covers creation, side effects, follow-up steps, and authorization. Minor omission: does not explain that the created form is empty and requires additional calls, but that is implied by the batch_update_form reference.

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

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

Schema coverage is 100%, so baseline is 3. The description only reiterates 'title and optional description' which is already in the schema. It does not add extra context for the user_google_email or document_title 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 it creates a new Google Form with a title and optional description. It distinguishes itself from siblings like batch_update_form (modifies) and get_form (reads) by focusing on 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?

Explicitly tells when to use this tool (to create a new form) and provides alternatives for adding items (batch_update_form) and inspecting (get_form). Also mentions required OAuth scope.

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?

Given no annotations, the description discloses side effects (creates file in My Drive root, contains one default slide) and the OAuth requirement, but omits details about the return value or persistent behavior beyond creation.

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?

Five short, front-loaded sentences efficiently convey purpose, side effects, alternatives, and requirements 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?

Covers the essential context for creating a presentation, including differences from related tools and a prerequisite. The presence of an 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 coverage is 100%, so the description adds no new semantic meaning beyond what the schema already provides for the two 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 action ('Create a new empty Google Slides presentation') with a specific verb and resource, differentiating it from siblings like 'copy_drive_file' and 'batch_update_presentation'.

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

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

Explicitly mentions when to use alternative tools ('To add more slides use batch_update_presentation with createSlide; to duplicate an existing deck use copy_drive_file') and the required OAuth scope.

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

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

No annotations provided, so the description carries full burden. It discloses side effects ('creates a reaction visible to everyone'), limitations (Unicode only), and auth requirements. Could be more detailed about idempotency or response, but covers key behavioral aspects.

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

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

The description is four sentences, each serving a purpose: action, side effects, limitations/alternative, auth. No redundant information, efficiently 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 no annotations, the description covers purpose, usage guidelines, side effects, and limitations. An output schema exists, so return value details are not needed. The description is thorough enough for a typical create tool.

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

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

Schema coverage is 100%, but the description adds value by clarifying that 'emoji_unicode' must be a Unicode character and that custom emoji are not supported. This extra context helps the agent avoid invalid inputs.

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 'Add an emoji reaction to a Chat message' with a specific verb and resource. It distinguishes from sibling tools like 'send_message' by noting that it is for reactions, not posting new messages.

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

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

The description explicitly says when not to use it (Custom Workspace emoji not supported), provides an alternative ('For posting a new message use send_message'), and specifies the required OAuth scope ('Requires the chat_write OAuth scope').

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 discloses the side effect of creating a Drive project and the required OAuth scope. However, it omits details like project privacy, location, rate limits, or whether the user must be the owner. This is adequate but not rich.

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

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

Four concise sentences, front-loaded with the core purpose. Each sentence adds distinct information: purpose, side effects, parameter usage, and prerequisites. No redundancy or filler.

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

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

For a 3-parameter creation tool with an output schema, the description covers side effects, prerequisites, optional parameter guidance, and references a follow-up tool. It fully equips the agent to decide and invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by explicitly stating that omitting parent_id creates a standalone project, which complements the schema's description. It clarifies the decision point for using the optional parameter.

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

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

The description starts with a clear verb-resource pair: "Create a new (standalone or container-bound) Apps Script project." It distinctly specifies the resource (Apps Script project) and differentiates from siblings like list_script_projects, update_script_content, and delete_script_project.

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 explains when to use the optional parent_id (bound script) versus omit (standalone), mentions the prerequisite OAuth scope, and directs to update_script_content for adding files. It lacks explicit 'when not to use' statements but provides adequate contextual guidance.

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

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

With no annotations, the description carries the full burden. It discloses the side effect ('appends a new tab at the end') and the OAuth requirement. However, it could also mention that the operation modifies the spreadsheet, which is implied but not explicit.

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 with two targeted sentences plus a line about alternatives and auth. Every sentence adds value, no fluff, and the key action is 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 simplicity (3 required params, high schema coverage, output schema exists), the description covers purpose, side effects, auth, and alternatives sufficiently. No gaps remain for agent decision-making.

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

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

Schema coverage is 100% and each parameter has a good description. The tool description does not add extra meaning beyond the schema, as the uniqueness constraint for sheet_name is already in the schema. Baseline score is appropriate.

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

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

The description clearly states the action: 'Add a new tab (sheet) to an existing spreadsheet.' It uses a specific verb ('Add') and resource ('tab to spreadsheet'), effectively distinguishing from siblings like create_spreadsheet (new spreadsheet) and manage_sheet_tabs (rename/reorder/delete).

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

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

The description explicitly provides alternatives: 'To rename/reorder/delete tabs use manage_sheet_tabs. For a brand-new spreadsheet use create_spreadsheet.' It also mentions the required OAuth scope, guiding proper usage.

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

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

No annotations provided, so description carries full burden. Details OAuth scope, creates exactly one shape per call, returns object ID, and explains transparent fill behavior. Could add more about error cases but sufficient.

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?

Well-structured, front-loaded with purpose, bullet points for alternatives, and clear notes. Every sentence adds value without redundancy.

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

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

Given complexity (9 params, 4 required) and presence of output schema, description covers behavior, usage, parameters, and return value. No gaps identified.

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 89% (baseline 3). Description adds significant value: explains shape_type with common values and link, EMU units for position/size, and fill_color optionality. Exceeds baseline.

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

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

Clearly states it creates a shape element (rectangle, ellipse, etc.) on a Google Slide. Distinguishes from sibling tools like create_slides_text_box and style_slides_shape.

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

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

Explicitly says when to use (build layouts programmatically) and when not (use create_slides_text_box for text, style_slides_shape for styling). Also mentions follow-up actions like adding text via batch_update_presentation.

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

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

With no annotations, description carries full burden. It discloses behavior (adds text box, positions in EMU, requires OAuth scope) but lacks details on potential side effects, error cases, or limits (e.g., max text length). Still, it covers key behavioral traits sufficiently.

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?

Concise at 5 sentences, front-loaded with purpose and alternatives, then units and auth. Every sentence adds value with no redundancy or filler.

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

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

Given 11 parameters, no annotations, and existing output schema, the description is fairly complete. It covers purpose, usage guidelines, units, and auth. Lacks details on behavior when optional parameters are omitted or output format, but schema and output schema compensate. Good overall.

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

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

Schema coverage is 100% with descriptions for each parameter. Description adds context about EMU units and OAuth scope but does not enrich individual parameter meanings. Baseline of 3 is appropriate since schema already does the heavy lifting.

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

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

Clearly states 'Add a text box to a slide with initial content and position' and distinguishes from sibling tools (create_slides_shape for shapes, batch_update_presentation for editing existing text). The verb+resource combination is specific and unambiguous.

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

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

Explicitly tells when to use this tool (for text content), and when to use alternatives (create_slides_shape for geometric shapes, batch_update_presentation for editing existing text). Provides clear context and exclusions.

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

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

With no annotations, the description carries full burden. It discloses side effects (creates new file owned by user in My Drive root) and auth requirement (spreadsheets OAuth scope). It doesn't describe return value, but output schema exists. Minor omission of whether creation is reversible or conflicts.

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

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

Two sentences plus side effect/alternatives, no wasted words. Front-loaded with purpose, then important context. Highly 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 output schema exists, the description sufficiently covers purpose, side effects, alternatives, and auth. It doesn't explain return values but that's covered by schema. Lacks mention of what happens if file with same title exists, which could be added for 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?

Input schema has 100% coverage with descriptions for all 3 parameters. The description adds no additional detail beyond schema, so baseline 3 is appropriate.

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

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

The description clearly states it creates a new empty Google Spreadsheet in My Drive with specific verb and resource. It distinguishes from siblings like create_sheet (adds tabs to existing), create_drive_file, and import_to_google_doc, providing precise differentiation.

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

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

It provides clear context for when to use this tool vs alternatives (create_sheet for tabs, create_drive_file/import_to_google_doc for .xlsx uploads) and mentions required OAuth scope. However, it doesn't explicitly exclude all inappropriate uses, such as editing existing files.

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

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

No annotations provided, so description carries full burden. Discloses it creates and populates reliably, data format rules, and suggests verification. Does not detail potential failures or side effects, but sufficient.

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?

Structured with steps and critical notes, front-loaded. Some redundancy (example repeats format requirements) but overall well-organized and helpful.

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

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

Given complexity (6 params, output schema exists, no annotations), description is comprehensive. Includes workflow, data format, index criticality. Return values covered by 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 100%, but description adds value with data format example, index source requirement, and bold_headers default behavior. Provides meaning beyond 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?

Clearly states 'Creates a table and populates it with data' – specific verb and resource. Distinguishes from siblings like append_table_rows which appends to existing tables.

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

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

Provides explicit mandatory workflow (inspect_doc_structure first, use total_length as index) and data format requirements. Lacks explicit when-not-to-use or alternatives, but steps are clear.

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

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

No annotations exist, so description carries full burden. Describes side effects (freezes code, creates versionNumber), immutability (cannot edit/delete), required OAuth scope. Could mention return value, but output schema exists.

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

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

Front-loaded with clear action sentence, followed by essential side effects, constraints, and references. No redundant text.

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

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

Output schema exists, so return values are covered. Description addresses side effects, immutability, related tools, and auth scope. Lacks mention of prerequisite script project existence, but overall sufficient 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 coverage is 100%, so parameters are fully documented in schema. Description adds contextual meaning but no extra parameter-specific details beyond schema. Baseline 3 is appropriate.

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

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

Description clearly uses verb 'create' with specific resource 'immutable version snapshot of an Apps Script project', distinguishing it from sibling tools like list_versions (listing) and manage_deployment (deployment management).

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

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

Provides context on when to use this tool (create a snapshot for deployment), and references alternatives: manage_deployment for pinning and list_versions for listing. Does not explicitly state prerequisites or exclusions, but adequate.

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 mentions returning runtime/source information but fails to specify if the operation is read-only, what permissions are needed, or any side effects. The temporary nature is noted but insufficient for a diagnostic 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 consists of two sentences that are clear and front-loaded. It is efficient but could potentially be more concise without losing meaning.

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

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

For a simple tool with one parameter and an output schema, the description covers purpose and context but lacks details on what exactly is returned or how to interpret the output. The temporary nature is highlighted, but completeness is moderate.

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

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

The input schema has one required parameter with 0% coverage (no description). The tool description does not mention the parameter at all, failing to add context about the 'user_google_email' parameter's role or usage.

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 returns runtime/source information for diagnosing stale MCP server instances, with a specific verb and resource. It distinguishes itself from sibling tools as the only diagnostic tool focused on runtime verification.

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 its temporary diagnostic purpose and intent to verify which code checkout is loaded. However, it does not provide explicit when-not-to-use instructions or alternatives, though no sibling offers similar functionality.

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 fully covers behavioral aspects: it explains what the tool shows (dimensions, positions, content, insertion indices) and how to interpret the output, leaving no ambiguity about its non-destructive, read-only nature.

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 headings and bullet points, making it easy to scan. While slightly verbose, it front-loads key information and each section adds value, earning a high 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?

The description is fully complete for a debugging tool: it covers when to use, what to expect, how to read output, and integrates into workflow. Presence of output schema further ensures no 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 coverage is 100%, and the description does not add significant new meaning beyond the schema's parameter descriptions. The baseline of 3 is appropriate because the schema already provides clear definitions.

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 identifies the tool as a debugging utility for tables, listing specific error scenarios and use cases. It distinguishes itself from sibling tools by being diagnostic rather than manipulative.

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

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

Explicitly states when to use the tool (immediately on table issues, after creation, before population, after failure) and references a sibling tool (populate_existing_table) for workflow context, providing clear usage boundaries.

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

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

With no annotations provided, the description fully carries the burden. It discloses permanent removal, notes that UI undo works but no API undo, and states the required OAuth scope. This provides complete behavioral insight.

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

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

The description is concise at three sentences, front-loaded with the primary action, and every sentence adds value. There is no redundant or extraneous information.

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

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

Given that an output schema exists (not shown) and the tool is a destructive operation, the description covers side effects, prerequisites, and alternatives. It is complete for an agent to understand impact and requirements.

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

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

The input schema already covers all three parameters with descriptions (100% coverage). The description adds value by explaining the source of tab_id ('Get from list_doc_tabs or inspect_doc_structure'), but does not significantly expand beyond the schema.

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

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

The description clearly states the action ('Delete a tab') and the resource ('and its entire sub-document from a Google Doc'). It distinguishes from the sibling tool 'update_doc_tab' by noting that renaming is an alternative.

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 by stating when to use this tool (permanent delete) and offers an alternative: 'To just rename a tab use update_doc_tab.' It also mentions that there is no API undo, which helps set expectations.

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

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

No annotations provided, but description details permanence, Drive API usage, no API undo, web UI restore possibility, and OAuth scope. Thorough for a destructive 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?

Concise, front-loaded with purpose, then side effects, alternatives, requirements. Every sentence adds value, no waste.

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

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

Given output schema exists and schema coverage is high, description covers key behavioral aspects: permanence, side effects, restore path, alternative, auth scope. Complete for decision-making.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add extra meaning beyond schema descriptions; it mentions the authenticated account and script ID implicitly.

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

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

The description states 'Permanently delete an Apps Script project' with specific verb and resource. It distinguishes from sibling like manage_deployment for disabling.

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

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

Explicitly says when to use (permanent deletion), when not (use manage_deployment for disabling), and provides OAuth scope requirement. Clear guidance.

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

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

Discloses key behaviors: permanence of deletion, use of Slides UI undo for recovery, non-idempotent nature ('re-calling with the same ID after success returns an error'), and required OAuth scope. No annotations provided, so the description carries full burden and does so thoroughly.

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?

Description is concise (~100 words), front-loaded with the core action, followed by usage details, requirements, and warnings. Every sentence adds meaningful 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?

Covers all essential aspects: what it does, what it works on, permanence, idempotency, recovery options, and scope requirement. Existence of an output schema (not shown) likely complements return value information, but description itself is self-sufficient.

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

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

Schema covers 2 of 3 parameters with descriptions (presentation_id, object_id). The description adds value by explaining how to obtain object IDs from get_presentation or creator tools. However, user_google_email parameter is not described in either the schema or the description.

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

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

Description explicitly states 'Delete any object from a Google Slides presentation by its object ID', clearly enumerating supported object types (slide, shape, text box, etc.). Distinct from sibling tools like duplicate_slide or batch_update_presentation.

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

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

Provides clear context on what can be deleted and the effect of different object IDs, and includes a limitation ('Cannot delete master/layout pages'). However, it does not explicitly discuss when to use this tool versus alternatives like batch_update_presentation.

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