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

No annotations provided, so description carries full burden. It discloses dry_run behavior and gradient_points override, but lacks details on auth requirements, error handling, or mutation scope. Adequate but not thorough.

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 well-structured with Args block. Each parameter is explained concisely. No unnecessary repetition, though could be slightly more compact.

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 10 parameters and no annotations, the description covers most aspects but lacks context on error conditions, rate limits, or when to use dry_run vs actual mutation. Output is minimally described ('str: Confirmation').

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

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

With 0% schema coverage, the description provides extensive parameter semantics: explains condition_type examples, condition_values format, gradient_points structure, and parameter dependencies. Adds significant value beyond 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 'Adds a conditional formatting rule to a range' with a specific verb and resource. The tool name and description distinguish it from siblings like delete_conditional_formatting and update_conditional_formatting.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., update_conditional_formatting). The description implies usage via parameter details but lacks when-not-to-use or prerequisites.

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

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

No annotations exist, so the description carries full burden. It discloses that the tool modifies messages (dry_run prevents mutation) and returns a confirmation string. It does not mention authorization needs, rate limits, or thread implications, but the core behavior is adequately described.

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 structured as a Python docstring with a one-line summary followed by Args and Returns sections. It is concise, front-loads the purpose, and contains 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 no output schema and 5 parameters, the description covers inputs well and notes a confirmation string return. It lacks details on error handling, partial failures, or quotas, but for a batch mutation tool, it is reasonably complete.

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

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

The description explains all five parameters beyond the schema: user_google_email ('The user's Google email address'), message_ids ('list of message IDs'), and dry_run ('preview batch label changes without mutating messages'). Schema coverage is only 40%, but the description compensates 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: 'Adds or removes labels from multiple Gmail messages in a single batch request.' It specifies the action (adds/removes), resource (labels on Gmail messages), and batch scope, distinguishing it from sibling tools like manage_gmail_label (label CRUD) and modify_gmail_message_labels (likely single message).

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

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

The description mentions a dry_run parameter to preview changes without mutation, providing a safety guideline. However, it does not explicitly state when to use this batch tool over alternatives like modify_gmail_message_labels for single messages, nor does it provide exclusions or prerequisites.

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

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

No annotations are provided, so the description must convey behavioral traits. It discloses sequential processing, dry_run functionality, and that the return is a success/failure summary. However, it does not mention error handling for partial failures, permission requirements, or idempotency.

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 well-structured: a one-sentence summary followed by a bulleted list of parameters and a return value statement. Every sentence adds value and the key purpose 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 tool's complexity (batch operation, nested objects) and absence of annotations, the description covers the essential: return value, dry_run behavior, sequential processing. It lacks details on error handling, permissions, and rate limits, but these are not critical for basic usage. An output schema is implied (returns a string), which helps.

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 listing and explaining each parameter (user_google_email, file_id, recipients, send_notification, email_message, dry_run). The nested $defs also provide descriptions for ShareRecipient fields. This is thorough, though some parameter behavior (e.g., default values) could be better integrated.

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 shares a Google Drive file or folder with multiple users or groups in a single operation. It uses a specific verb-resource pair and distinguishes itself from sibling tools like share_drive_file (single share) and update_drive_permission (modifying existing permissions).

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

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

The description mentions sequential processing and suggests splitting large recipient lists, but it does not explicitly compare with alternatives like share_drive_file for single recipients. The context implies batch use but lacks explicit when-to-use or 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?

No annotations are provided, so the description bears full burden. It discloses atomicity, dry_run capability, lists supported operation types, and shows example operations. It does not detail error handling or permissions but is fairly transparent.

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: a concise purpose sentence, Args list, example, and return type. It is thorough but not overly verbose; however, 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 presence of an output schema (confirmation message), the description covers purpose, parameters, examples, and return. It lacks details on error handling, limits, or prerequisites, but is generally complete for a batch update 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%, but the description fully explains each parameter: user_google_email, document_id, operations structure with types, and dry_run behavior. Examples illustrate usage effectively, far exceeding minimal 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 it executes multiple document operations in a single atomic batch update, using a specific verb and resource. This differentiates it from sibling tools like modify_doc_text or insert_doc_elements that handle individual operations.

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

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

It implies use when multiple operations are needed atomically, and provides example operations. However, it does not explicitly state when not to use it (e.g., for a single operation) or mention 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?

No annotations are provided, and the description does not disclose behavioral traits such as whether updates are destructive, append-only, or require specific permissions. The tool modifies a presentation but lacks details on side effects.

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

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

The description is well-structured in a docstring format with Args and Returns sections. It is concise but covers the essential parameters and return type without extraneous 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?

Given the tool has 4 parameters and an output schema (implied), the description covers the main functionality but misses the 'dry_run' parameter and lacks behavioral details. It is adequate for basic understanding but not fully complete.

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

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

The description adds meaning for three of four parameters (user_google_email, presentation_id, requests) with explicit descriptions. However, the 'dry_run' parameter with a default of true is entirely omitted from the description, and schema coverage is 0%, so the description partially compensates but is incomplete.

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

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

The description clearly states 'Apply batch updates to a Google Slides presentation,' which is a specific verb+resource combination. However, it does not differentiate from similar tools like 'batch_update_doc' for Google Docs, but given the sibling list includes many different tools, the purpose is still clear.

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

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

No guidance on when to use this tool versus alternatives (e.g., individual updates or other batch operations). No prerequisites or context provided.

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

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

The description states it is a read-only check, which is transparent. However, it lacks details on behavior for edge cases (e.g., file not found, multiple matches) and prerequisites like authentication. With no annotations, the description carries the full burden but only partially meets it.

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

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

The description is extremely concise: one sentence for the purpose and a brief arg/returns section. No unnecessary information, and it 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 tool's simplicity (2 parameters, no nested objects), the description adequately covers purpose and parameters. However, it lacks usage context relative to siblings and does not fully explain the return value structure, though an output schema exists.

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 explains both parameters: user_google_email and file_name, stating their types and roles. Since the input schema has 0% description coverage, the description fully compensates by providing clear semantics.

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

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

The description clearly states the tool's action: it searches for a file by name and checks if public link sharing is enabled. It uses specific verbs and identifies the resource (file), and this is distinct from sibling tools like get_drive_file_permissions or get_drive_shareable_link.

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. Sibling tools exist for broader permission checks or link retrieval, but the description does not differentiate usage contexts or mention 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?

Discloses that tasks are 'marked as hidden' rather than deleted, but lacks details on authentication needs, rate limits, or reversibility. With no annotations, the description carries full burden but only partially fulfills it.

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?

Main description is two sentences followed by structured Args/Returns. Front-loaded with purpose, but the docstring format adds a few extra lines without being verbose.

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

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

Covers purpose, parameters, and basic behavior (hidden). With output schema present, return values are already documented. Lacks context on permissions, side effects, or restoration of hidden tasks, making it slightly incomplete.

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 explicitly lists each parameter with its purpose, default for dry_run, and required status, adding significant meaning beyond the raw 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 'Clear all completed tasks from a task list' with specific verb and resource. Distinguishes from siblings like delete_task or update_task by focusing on completed tasks as a group.

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 the action but does not explicitly state when to use vs alternatives (e.g., delete_task for individual tasks). The dry_run parameter implies testing, but no direct 'use this when' guidance.

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

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

No annotations provided, so description bears full burden. It mentions input methods but does not disclose side effects (e.g., token creation/overwrite), error conditions, or idempotency. Vague about what happens on repeated calls.

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

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

Extremely concise (two sentences) with front-loaded purpose and no wasted words. Efficient for an AI agent 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?

Covers the OAuth completion flow and input methods. Mentions prerequisite start_google_auth. But omits details on output (despite output schema existing) and does not explain required parameters. Somewhat incomplete for a complex auth flow.

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?

Low schema coverage (0%) but description adds meaning for three parameters (callback_url preference, fallback others). However, required parameters service_name and user_google_email are not explained, 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?

Description clearly states the tool completes Google OAuth after start_google_auth, using a specific verb and resource. It distinguishes from sibling start_google_auth and explains preferred vs fallback input.

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 preferred input (callback_url) and fallback (authorization_code + state) with clear conditions. Implies usage after start_google_auth, but lacks explicit when-not-to-use or comparison to other auth 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?

No annotations provided, so description details behavior: dry_run default creates preview, returns confirmation string, version_number must be >=1. Discloses the dry run vs actual mutation distinction.

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 args list; action is front-loaded. Some redundancy with 'Returns:' line, 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 inputs and output well for a create tool. Missing prerequisites (e.g., existing script project) and auth requirements, but adequate given 5 params and 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?

With 0% schema description coverage, description thoroughly explains each parameter: user_google_email required, script_id, description, version_number constraint (>=1), dry_run default. Adds significant 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?

Description clearly states 'Create an Apps Script deployment' with specific verb and resource, distinguishing it from sibling tools like update_deployment and delete_deployment.

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

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

No guidance on when to use this tool versus alternatives like update_deployment or list_deployments. Missing prerequisites or context for creation.

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

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

No annotations are provided, so the description carries the full burden. It thoroughly describes behavior for parse_markdown, checklist_mode, mention_mode, and dry_run, and includes examples. However, it omits information about required permissions, rate limits, or edge cases like duplicate titles.

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 Args, Returns, and Examples sections, front-loading the purpose. Every sentence adds value, neither verbose nor terse, making it easy to parse 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 the tool's complexity (7 parameters, 2 required, output schema exists without return value details), the description is complete. It covers all parameters, return format, and provides practical examples, ensuring the agent can use the tool correctly.

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

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

Schema description coverage is 0%, meaning no parameter descriptions in the schema. The description compensates fully by explaining each of the 7 parameters, including defaults, accepted values (e.g., checklist_mode options), and effects with examples. 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 action ('creates a new Google Doc') and the resource ('Google Doc'), with specific detail about optional initial content. It distinguishes from siblings by focusing on Google Docs creation with markdown parsing, though not explicit about alternatives.

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

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

No guidance on when to use this tool versus alternatives like create_drive_file or update_google_doc. The description explains parameters and behavior but does not provide selection criteria or exclusion 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 must bear the full burden of behavioral disclosure. It only states the action (create) without mentioning side effects, required permissions, error conditions, or return values. This is insufficient for an agent to predict 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 a single, concise sentence with no extraneous words. It front-loads the main action. However, conciseness sacrifices necessary detail; a slightly longer description could improve completeness without losing 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 three required parameters and no annotations or output schema details (despite 'Has output schema: true'), the description fails to explain return values, error handling, or parameter relationships. The agent lacks key information to use the tool correctly.

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

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

The input schema lists three parameters with zero description coverage. The tool description does not clarify their meanings: for example, what user_google_email represents (e.g., comment author or target user), expected format for comment_content, or constraints on document_id. The agent receives no semantic guidance beyond parameter names.

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

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

The description 'Create a new comment on a Google Document' uses a specific verb and resource, clearly distinguishing the tool's action from sibling tools like read_document_comments or reply_to_document_comment. The combination of tool name and description leaves no ambiguity about its purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives such as create_presentation_comment or create_spreadsheet_comment. It offers no prerequisites, context for use, or exclusions, leaving the agent without decision support.

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 the dry_run parameter for preview, file content options, and shared drive support. However, it does not mention what happens if a file with the same name exists or permissions required, which would be beneficial.

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

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

The description is well-structured with a summary line, an Args section, and a Returns line. It is clear and informative, though slightly lengthy due to the number of parameters. No redundant sentences.

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 7 parameters and no annotations, the description covers purpose, parameters, and return value. It lacks error scenarios or conflict handling, but for a creation tool, it provides a solid foundation.

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

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

The input schema has 0% description coverage, so the description fully compensates by explaining each parameter's purpose, defaults, and constraints (e.g., fileUrl protocols, folder_id for shared drives). 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 action 'Creates a new file in Google Drive' and specifies the capability of supporting shared drives, which differentiates it from sibling tools like create_doc or create_sheet. The verb and resource are 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 does not provide guidance on when to use this tool versus alternatives like create_doc or create_spreadsheet. It lacks 'when to use' or 'when not to use' information, nor does it mention context switching.

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

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

Since no annotations are provided, the description carries the full burden. It discloses critical behaviors: dry_run for preview, default values, time formats, reminder constraints, and return type. However, it does not mention authorization requirements or rate limits.

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

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

The description is long due to detailed parameter docs, but it is well-structured with 'Args' and 'Returns' sections. Every sentence adds value, and the main action is front-loaded. It could be slightly more concise, but is appropriately sized for a complex 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 high parameter count (16), 0% schema coverage, and presence of output schema, the description is exceptionally complete. It covers all parameters, behaviors like dry_run, and return value, leaving little ambiguity for an agent to 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?

The schema description coverage is 0%, so the description fully compensates. It provides detailed explanations for all 16 parameters, including formats, examples, defaults, and allowed values (e.g., for reminders and visibility), which is far beyond what the schema alone offers.

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 'Creates a new event.' The verb 'creates' and resource 'event' are specific, and the tool is easily distinguished from siblings like delete_event, modify_event, and get_events.

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

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

The description implies usage by detailing all parameters and a dry_run option, but it does not explicitly contrast with modifying or deleting events. However, the sibling tool names provide context, making the purpose 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 are provided, so the description carries the full burden. It describes the return value (confirmation with ID and URL), but does not disclose side effects, authentication requirements, rate limits, or what happens if the form already exists. The behavioral transparency is average.

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 standard docstring format with Args and Returns sections. The first sentence is fairly concise but includes the confusing phrase 'provided form message'. The overall length is reasonable, but it could be 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 the tool has 5 parameters, no annotations, and a complex environment with many sibling tools, the description is incomplete. It does not clarify the dry_run parameter, prerequisites (e.g., Google Forms API access), or the meaning of 'provided form message'. The output schema exists but the description could still benefit from more 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?

Schema description coverage is 0%, so the description must compensate. It explains user_google_email, title, description, and document_title with brief comments. However, it completely omits the dry_run parameter, which is present in the schema but undocumented in the description, creating a significant 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 it creates a new form using the provided title. The verb 'create' and resource 'form' are explicit, and the sibling tools include other create tools, but the description specifies 'form', distinguishing it. The phrase 'provided form message' is slightly ambiguous but does not obscure the core purpose.

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

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

No guidance on when to use this tool versus alternatives like create_doc or create_sheet. There is no mention of prerequisites, context, or exclusions. The description only states what it does, leaving the agent without selection criteria.

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

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

No annotations are provided, so the description carries the full burden. It discloses dry_run behavior (preview vs. creation) and return of a confirmation message. However, it does not mention side effects, authorization needs, 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 concise and well-structured with a clear docstring-style format listing arguments and return. Every sentence adds value, though the format is slightly verbose for the context.

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

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

Given that an output schema exists (though not shown), the description adequately covers the tool's purpose, key parameters, and dry_run nuance. It lacks some context like error handling or rate limits, but is reasonably complete for a filter 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 50% (criteria and action have brief descriptions). The description adds value by clarifying user_google_email as required, dry_run default and preview behavior, and the types. It compensates partially 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 'Creates a Gmail filter using the users.settings.filters API,' providing a specific verb and resource. It distinguishes itself from sibling tools like delete_gmail_filter and list_gmail_filters.

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

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

The description offers no explicit guidance on when to use this tool versus alternatives or when not to use it. The dry_run parameter hints at a testing workflow, but lacks explicit 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. It mentions creation but does not disclose potential side effects (e.g., file creation in Drive), the role of the dry_run parameter, or any required permissions.

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

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

The description is short (4 sentences) and well-structured with Args and Returns sections, containing no 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?

The tool is simple with 3 parameters, but the description omits explanation of the dry_run parameter and does not provide enough behavioral context for a creation tool without 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 clarifies the purpose and default of user_google_email and title, but fails to mention the dry_run parameter, which is a significant 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 'Create a new Google Slides presentation,' which is a specific verb and resource. It distinguishes from sibling tools like create_doc and create_sheet.

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 basic Args and Returns but does not explicitly state when to use this tool versus alternatives, nor does it mention prerequisites or context for use.

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

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

With no annotations provided, the description carries the burden of disclosure but only states it 'creates a new comment'. It does not mention required permissions, side effects (e.g., modification of the presentation), 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?

A single, efficient sentence conveys the core purpose with no extraneous information. Every word earns its place.

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

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

Despite having an output schema, the description omits any details about return values, error handling, or additional context. For a tool with three required parameters, it is severely incomplete.

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

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

The input schema has 0% description coverage, and the description provides no explanation of parameter meanings, formats (e.g., comment_content format), or constraints beyond the schema field names.

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

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

The description clearly states the verb 'Create' and resource 'comment on a Google Presentation', distinguishing it from sibling tools like create_document_comment and create_spreadsheet_comment.

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

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

No guidance on when to use this tool versus alternatives, nor any context on prerequisites or exclusions. The description simply states what it does 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?

No annotations are provided, so the description carries full burden. It discloses that dry_run defaults to True, providing a preview without mutation, and that the return is a confirmation string. However, it lacks details on side effects, permissions, or error cases.

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, well-structured with Args/Returns sections, and contains no superfluous information. 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 complexity and presence of an output schema, the description covers parameter semantics and return type adequately. It lacks contextual guidance on integration with other script tools or error handling, but is sufficient for basic 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 meaningful explanations for all four parameters, including default values and required status, compensating fully for the schema 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 'Create a new Apps Script project,' which is a specific verb+resource. It distinguishes from sibling tools like get_script_project, delete_script_project, etc.

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

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

The description does not provide explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. Usage is implied by the tool's purpose.

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

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

With no annotations, the description carries the full burden. It discloses dry_run behavior (default True, returns planned creation without mutation) and return type (confirmation string). Missing details on error conditions (e.g., duplicate sheet name), authentication requirements beyond user_google_email, and potential side effects like renaming existing sheets.

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 structured with a purpose statement, Args list, and Returns note. It is reasonably concise, though the Args section repeats 'Required.' for each parameter, which could be condensed without loss.

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 basic usage: creating a sheet with given name in a spreadsheet. Describes dry_run behavior and return type. Missing details on error handling (e.g., if sheet name exists), maximum sheets per spreadsheet, or any other constraints. Output schema exists but is not provided; description compensates with text return type.

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 explain parameters. It does so in the Args section: each parameter has a brief description, type, and requirement status (e.g., 'Required.'). This adds meaning 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 'Creates a new sheet within an existing spreadsheet,' specifying the verb and resource. It distinguishes from siblings like create_spreadsheet, which creates a new spreadsheet, not a sheet within one.

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 requiring a spreadsheet_id, suggesting the tool is for existing spreadsheets. However, it does not explicitly state when to use or avoid this tool compared to alternatives, such as create_spreadsheet for new spreadsheets or modify_sheet_values for editing cells.

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 describes the creation process but omits the behavior of the dry_run parameter (default true), which affects whether the spreadsheet is actually created. This is a critical behavioral 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 well-structured with Args and Returns sections, making it easy to scan. It is concise with no unnecessary sentences, though it could be slightly more compact.

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 (not shown) and 4 parameters, the description covers creation purpose, required params, optional sheet_names, and return value. However, the omission of dry_run and lack of error or permission info leave 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 0%, so the description must compensate. It explains user_google_email, title, and sheet_names, adding meaning beyond the schema. However, it fails to mention the dry_run parameter, which is present in the schema with a default of true, reducing completeness.

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 'Creates a new Google Spreadsheet,' which is a clear verb+resource pair. It effectively distinguishes from siblings like create_doc, create_sheet, and create_drive_file.

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

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

No guidance on when to use this tool versus alternatives (e.g., create_sheet, create_drive_file). There is no mention of prerequisites, such as having Google Drive access or the need for user authentication.

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 only states creation without disclosing constraints, error handling, or side effects (e.g., requires write permissions, comment location). Minimal behavioral insight.

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

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

Single sentence is concise but lacks necessary detail. Not a model of efficiency as it sacrifices completeness for brevity.

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

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

Given no annotations, low parameter info, but presence of output schema could compensate. Description fails to cover return values or error cases, leaving the tool's full behavior unclear.

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%. Description adds no parameter details beyond names. For three required parameters (user_google_email, spreadsheet_id, comment_content), there is no explanation of format, constraints, or role.

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 creates a new comment on a Google Spreadsheet. It uses specific verb and resource, and distinguishes from sibling tools like read_spreadsheet_comments and reply_to_spreadsheet_comment.

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

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

No guidance on when to use this tool vs alternatives. With many sibling tools for comments (read, reply, resolve), the description lacks context for 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?

No annotations provided, so description carries full burden. It details mandatory workflow, data format requirements, dry_run default behavior, and return value. Could mention potential failure modes or side effects, but otherwise thorough.

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 long but well-structured with steps, examples, and emphasis. Every sentence adds value; could be slightly more concise but readability is high.

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 0% schema coverage, complex parameters (2D list, index dependency), and no annotations, the description is exceptionally complete. It includes mandatory pre-step, data validation rules, and verification step. With output schema present, return description is 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 coverage is 0%, but description explains each parameter thoroughly: table_data format with example, index source from inspect_doc_structure, bold_headers and dry_run defaults. Only user_google_email and document_id are not elaborated, but they are self-explanatory.

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

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

The description clearly states it creates a table and populates it with data, distinguishing it from siblings like create_sheet or insert_doc_elements by combining creation and population in one 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?

Provides explicit step-by-step workflow, mandates calling inspect_doc_structure first, and warns against using arbitrary indices. Lacks explicit mention of when not to use this tool versus alternatives like insert_doc_elements.

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 lists parameters and return value but does not disclose side effects, error behavior, or authentication requirements. This is insufficient 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 front-loaded with a clear summary and then lists parameters in a structured format. Every sentence adds value, and the length is appropriate for the number of parameters.

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 (8 params, no annotations), the description covers the essential information: purpose, all parameters with types/defaults, and return value. It lacks examples or error handling, but the presence of an output schema (return string) helps. Overall fairly complete.

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

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

Schema description coverage is 0%, but the description adds meaning for each parameter: user_google_email is explained as required, due date format is given, and optional parameters are noted. However, it lacks explanation of how to obtain task_list_id or relationships between parent/previous.

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 the tool creates a task in a task list, which is a specific verb+resource. The sibling tools include update, delete, and get tasks, so the purpose is clear, though it doesn't explicitly distinguish from siblings.

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

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

The description provides no guidance on when to use this tool vs alternatives (e.g., update_task, move_task). There are no prerequisites, when-to-use, or when-not-to-use 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 'Create a new task list' without mentioning side effects, authentication requirements beyond the email parameter, or whether the operation is safe to repeat. It lacks critical 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 structured with Args and Returns sections but is slightly verbose. It could be more concise, e.g., combining the parameter explanations into a single sentence. However, it is not excessively long.

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 3 parameters, no annotations, and an output schema (not shown), the description should provide more context. It mentions the return type but misses the dry_run parameter, lacks usage guidance, and does not explain the overall behavior beyond creation. This is insufficient for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description should explain all parameters. It covers user_google_email and title with basic descriptions but completely omits the dry_run parameter (which has a default of true). This is a significant gap, as the agent needs to know the role of dry_run.

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 task list.' with a specific verb and resource. It distinguishes from sibling tools like create_task, delete_task_list, update_task_list, etc., which have different purposes.

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

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

No guidance on when to use this tool versus alternatives, such as when to create a new list versus updating an existing one. No context about prerequisites or situations where it should not be used.

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 the creation behavior, optional description, and the dry_run preview mode. However, it omits required permissions, side effects beyond mutation, and error scenarios.

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

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

The description is a docstring with Args and Returns sections, clear and well-structured. It is slightly verbose (6 lines) but efficient. Every sentence adds value.

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

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

For a tool with 4 parameters and an output schema, the description covers key behavioral aspects (creation, preview, return type). It lacks discussion of prerequisites, error handling, or permissions, but overall provides sufficient context for correct 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?

Despite 0% schema description coverage, the description fully explains each parameter: user_google_email (required Google email), script_id (project ID), description (optional), and dry_run (default True, preview without mutation). This adds critical meaning beyond the schema's type 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 states 'Create a new version for an Apps Script project.' It uses a specific verb and resource, distinguishing it from sibling tools like list_versions, get_version, and delete_deployment.

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 the tool's function but provides no guidance on when to use it versus alternative version-related tools. It mentions a dry_run parameter for preview but lacks explicit usage context or exclusions.

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

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

No annotations are provided, so the description carries full burden. It thoroughly explains what the tool shows (dimensions, coordinates, content, insertion indices) and how to read the output. It implies a read-only operation but does not explicitly confirm side effects or auth requirements.

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

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

The description is well-structured with bold headings, bullet points, and sections. It is front-loaded with urgency and provides valuable detail without redundancy. Slightly verbose but every section 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 tool with 3 parameters, no annotations, and an output schema, the description covers purpose, usage, output interpretation, and workflow integration. It lacks error handling details but is otherwise 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?

Parameters are described in the 'Args' section with clear definitions (e.g., 'Which table to debug (0 = first table, etc.)'). Since schema description coverage is 0%, the description compensates by adding meaning beyond type and requirement info.

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 is an 'ESSENTIAL DEBUGGING TOOL' for tables, listing specific failure scenarios and what it reveals (dimensions, cell positions, content). It distinguishes itself from sibling tools like 'populate_existing_table' by focusing on debugging and inspection.

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 when-to-use scenarios (e.g., 'table population put data in wrong cells', 'table not found errors') and workflow integration steps. It does not explicitly state when not to use, but the guidance is clear and context-rich.

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 dry_run behavior and return value but does not explicitly emphasize the destructive nature when dry_run is false.

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 Args and Returns sections, front-loading the purpose. It is appropriately sized but 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 presence of an output schema and the tool's straightforward nature, the description adequately covers input parameters and return behavior, though more context about the rule state returned could be added.

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

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

Schema coverage is 0%, but the description provides detailed explanations for all 5 parameters, including defaults and behavior (e.g., sheet_name defaults to first sheet, dry_run returns planned deletion). This fully compensates for the lack of schema descriptions.

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

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

The description clearly states it deletes a conditional formatting rule by index on a sheet, with specific verb and resource. This distinguishes it from siblings like 'add_conditional_formatting' and 'update_conditional_formatting'.

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 parameter details but does not explicitly state when to use this tool vs alternatives or provide any 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?

No annotations are provided, so the description carries the full burden. It states that the tool deletes a deployment and that dry_run previews without mutation (defaults to True). However, it does not disclose side effects, irreversibility when dry_run is False, or required permissions. The description is adequate but lacks depth.

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

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

The description is concise: one sentence for purpose, then a bullet-like list of arguments. No extraneous information. Front-loaded with the action.

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 the tool is simple (deletion with a dry run option) and an output schema exists (returning a string), the description covers the essential information. However, it could mention that deletion is irreversible when dry_run is False or that specific permissions are required.

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

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

Schema coverage is 0% (no parameter descriptions in the schema), but the description compensates by listing each parameter with a brief explanation: user_google_email (Required, user's email), script_id (project ID), deployment_id (ID to delete), dry_run (preview without mutation, defaults True). This adds meaningful context beyond type and required fields.

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 'Delete an Apps Script deployment,' which is a specific verb and resource. It distinguishes itself from siblings like `create_deployment` and `update_deployment` by specifying the delete action.

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

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

No explicit guidance on when to use this tool versus alternatives. While the dry_run parameter hints at preview behavior, there is no mention of prerequisites, when to use delete vs create/update, or when not to use this tool.

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

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

The description lacks transparency: it states 'Deletes an existing event' but the dry_run parameter defaults to True, meaning the default behavior is a preview, not deletion. This contradicts the primary claim and misleads about the tool's 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 structured as a clear docstring with Args and Returns sections, front-loading the purpose. It is moderately concise, though the parameter descriptions could be slightly tighter.

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

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

The description covers all parameters and return type, but lacks context on error conditions (e.g., event not found), permissions required, and the implications of dry_run=False. The tool's complexity is moderate, so this is acceptable but incomplete.

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 meaning to all four parameters beyond the schema (which has 0% description coverage). It explains the purpose of each parameter, including the dry_run preview behavior, and notes defaults.

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 deletes an existing event, using a specific verb and resource. It implicitly distinguishes from sibling tools like create_event and modify_event, which are for adding or altering 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?

No guidance is provided on when to use this tool versus alternatives (e.g., modify_event for non-destructive changes). There is no mention of prerequisites like event ownership or required authorization.

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

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

The description explains the deletion action and the dry_run preview, but lacks disclosure of permissions required, irreversibility, or other side effects. Annotations are absent, so description carries full burden.

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—two line summary plus clear Args and Returns sections. Every sentence provides necessary information without 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?

For a 3-parameter tool with low schema coverage and no annotations, the description covers all params and return type. With output schema present, it is adequately complete, though behavioral details are missing.

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

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

With only 33% schema coverage, the description adds meaning for all parameters: explains user_google_email, filter_id, and especially dry_run's preview behavior. This compensates for schema 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 'Deletes a Gmail filter by ID', which is a specific verb and resource. It distinguishes from sibling tools like create_gmail_filter and list_gmail_filters.

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

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

The description implies when to use (when needing to delete a filter) and mentions dry_run for preview, but does not explicitly discuss alternatives or when not to use.

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

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

With no annotations, the description discloses that dry_run defaults to True (preview without mutation), and specifies the return type (confirmation string). This provides key behavioral insight beyond the schema.

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

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

The description is well-structured with a clear action line, a limitation note, and an args/returns section. 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?

The description covers purpose, limitations, parameters, and return values. For a deletion tool with an output schema, it is nearly complete; minor missing detail is irreversibility, but dry_run minimizes risk.

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

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

Schema coverage is 0%, but the description defines each parameter: user_google_email (required), script_id (required), and dry_run (defaults to True, preview). This fully compensates for the lack of schema 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 action ('Delete (trash)') and the specific resource ('standalone Apps Script project by Drive file ID'), distinguishing it from sibling tools like create_script_project or delete_deployment.

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 notes a limitation ('only standalone script files are supported. Container-bound scripts are not addressable'), guiding when not to use. It also explains the dry_run parameter, but does not name specific 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?

No annotations provided, so description carries burden. It discloses mutation and dry_run behavior but lacks details on irreversibility, permissions, or error handling. 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?

Description is concise with Args and Returns sections, no superfluous information. Every sentence adds value.

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

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

For a simple delete tool, it covers basic purpose, parameters, and return type. Missing error handling and irreversibility warning, but output schema is provided. Adequate for complexity.

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

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

Schema description coverage is 0%, but the description compensates by explaining each parameter's type and role, including the dry_run default and effect. Adds 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?

The description clearly states the tool deletes a task from a task list, distinguishing it from siblings like create_task, update_task, and move_task. The verb 'delete' and resource 'task' are specific.

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

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

No guidance on when to use vs alternatives, prerequisites, or when not to use. The description only explains parameters, not 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, the description carries the full burden. It discloses the key destructive behavior (deleting all tasks in the list) and the dry_run behavior. However, it does not mention authentication requirements or reversibility.

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

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

The description is concise with a clear structure: main effect, bulleted args, and return. The return description ('str: Confirmation message') is vague but brief. Overall efficient, though word count is acceptable.

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 (destructive, 3 params, no annotations), the description covers the essential effect and dry_run behavior. The output schema exists, so detailed return explanation is unnecessary. It is reasonably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the dry_run parameter's role but provides minimal detail for user_google_email and task_list_id beyond what the schema already indicates. The added value is average.

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 'Delete a task list' and notes the cascading deletion of all tasks in the list. This specific verb+resource distinguishes it from sibling tools like delete_task and clear_completed_tasks.

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 delete_task or clear_completed_tasks. The dry_run parameter is mentioned but not elaborated on for 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?

The description explains the dry_run parameter behavior and output files, but fails to disclose important behavioral traits like authentication requirements, potential modifications (none), or error handling. Without annotations, the description should provide more 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 concise and front-loaded with the core functionality. The bullet-pointed output structure is clear, though the Args section could be integrated more efficiently. 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?

The description covers purpose, output files, and parameter meanings with examples. However, it lacks usage context (when to use vs siblings), prerequisites (auth), and error scenarios. The presence of an output schema partially compensates for return value details.

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

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

The Args section explains each parameter's purpose, provides an example for file_id (search alias 'A'), and indicates defaults for dry_run. This adds significant meaning beyond the input schema, which only defines types and required fields.

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 downloads a Google Doc using 'Hybrid Split-Sync' and specifies the exact output structure (folder with _Full_Export.md and [TabName].md files). This distinguishes it from sibling tools like download_google_doc and export_doc_to_pdf.

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

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

No guidance on when to use this tool versus alternatives (e.g., download_google_doc, export_doc_to_pdf). The description does not mention prerequisites, such as required Google authentication or file accessibility.

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

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

Since no annotations are provided, the description carries the full burden. It discloses the dry_run behavior, providing a diff/preview format, and explains all parameters. It does not mention auth or rate limits, but the safety aspect is well-covered.

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

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

The description is concise (about 150 words) and front-loaded with the purpose. It uses a clear 'Args:' label to list parameters. While slightly verbose in the safety warning, it remains efficient and well-structured.

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

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

The description covers purpose, parameters, and safety behavior comprehensively. It lacks details on return value structure (beyond dry_run) and potential errors, but the presence of an output schema might compensate. Given no annotations, it is fairly complete for a download 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 adds crucial semantics for all 6 parameters, including the required user_google_email, format options, behavior of include_comments, rewrite_links, and the critical dry_run parameter. This far exceeds the schema's default 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 tool's action: 'Download content from a linked Google Doc and SAVE it to a local file.' This distinguishes it from siblings like get_doc_content (which retrieves content without saving) or export_doc_to_pdf (which exports to PDF but not necessarily to a local path).

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 highlights the safety default (dry_run=True) and the requirement to explicitly set dry_run=False to apply changes. This provides clear usage guidance. However, it does not explicitly compare to siblings like export_doc_to_pdf or download_doc_tabs, but the purpose itself implies saving to a local file is the key differentiator.

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

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

The description omits the 'dry_run' parameter, which defaults to true and controls whether an actual draft is created or just a preview. This is a critical behavioral detail not disclosed. No annotations are provided, so the description carries full burden but fails to be transparent.

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 summary, parameter list, returns, and examples. The examples are comprehensive but somewhat verbose. The omission of the 'dry_run' parameter from the parameter list is a structural flaw.

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, 3 required, and no annotations, the description covers most parameters with good detail. However, the missing 'dry_run' parameter and lack of information about side effects or rate limits leave gaps. The output schema is mentioned but not detailed.

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 value beyond the schema by explaining threading parameters (thread_id, in_reply_to, references) and providing examples. However, it omits the 'dry_run' parameter entirely, which is a significant gap. Schema coverage is 91% but the missing parameter lowers the score.

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

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

The description clearly states it creates a draft email in the user's Gmail account, supporting both new and reply drafts. It distinguishes from sibling tools like 'send_gmail_message' and 'modify_gmail_message_labels' by its focus on drafting.

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 detailed parameters and examples covering various usage scenarios (new draft, reply draft, with CC/BCC, HTML body). However, it lacks explicit guidance on when to use this tool versus alternatives like 'send_gmail_message' or when not to use it.

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

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

No annotations provided; description carries full burden. It explains export and save action, optional parameters, and return type, but lacks details on file overwrite behavior or authentication requirements.

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

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

Concise, well-structured with Args/Returns format. No unnecessary sentences.

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, parameters, and return value. Lacks edge cases or error handling, but output schema exists to supplement return info.

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

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

Schema coverage is 0%, but description adds clear meanings for all 4 parameters, including defaults for optional ones (e.g., pdf_filename defaults to original name + '_PDF').

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 'Exports a Google Doc to PDF format and saves it to Google Drive,' with a specific verb and resource. It distinguishes from siblings like download_google_doc and create_drive_file.

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

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

No guidance on when to use this tool vs alternatives (e.g., download_google_doc). Only explains optional parameters, not context for 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, the description carries full burden. It explains the dry_run behavior and return value, but does not disclose potential side effects like formatting changes or auth requirements beyond the email parameter.

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 followed by a structured Args/Returns section. It is clear and efficient, though the Args section 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?

With 6 parameters, no nested objects, and an output schema, the description covers the core behavior (find and replace) and the dry_run feature. It lacks details on prerequisites or regex support, but is sufficient for basic 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 covers 0% of parameter descriptions, but the Args section provides brief explanations for all 6 parameters (e.g., 'Text to search for'). This adds meaning beyond the schema 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 action 'finds and replaces text' and the resource 'Google Doc'. It distinguishes itself from sibling tools like 'modify_doc_text' through the explicit find-and-replace mechanism.

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

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

The description includes a dry_run parameter that defaults to True, indicating the tool can be used safely for previewing changes. However, it does not explicitly contrast with alternatives like 'modify_doc_text' or provide 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?

Since no annotations exist, the description carries the full burden. It discloses that the tool can mutate the sheet (with dry_run defaulting to true), explains color and number format types, and notes default sheet usage. However, it does not specify whether formatting is additive or overwriting, nor does it mention required permissions or rate limits.

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 brief summary paragraph followed by a clear Args list. It is appropriately sized for the 8-parameter tool and front-loads the purpose. Minor redundancy (e.g., repeating 'Required' in param descriptions could be trimmed) 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?

Given the tool's complexity (8 params, no annotations), the description covers all parameters, return type, and dry_run behavior. The presence of an output schema reduces the need to detail return values. Missing: error scenarios or effect on existing formatting, but still fairly complete for its class.

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 compensates fully by explaining every parameter in the Args section, including types, defaults, and optionality. For example, it clarifies that background_color accepts hex strings and number_format_type uses Sheets-defined types. This exceeds the baseline expectation.

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 action ('Applies formatting to a range') and the resources (background/text color, number/date formats). It is specific enough to distinguish this tool from value-modifying siblings like modify_sheet_values, though no explicit differentiation is given.

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 alternative formatting tools (e.g., add_conditional_formatting) or when not to use it. The description implies usage for formatting ranges but lacks explicit context 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, description provides behavioral details: for native Docs uses Docs API, for Office files downloads via Drive API and extracts text. Also mentions return includes metadata header. Lacks info on permissions or error handling, but adequate for a read 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?

Description is concise, uses a short paragraph and bullet points to explain file type handling and return format. Every sentence adds value; 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 two file types, schema with 2 required params, and presence of output schema, description covers behavior for different file types and return format. Missing error handling or prerequisites, but sufficient for typical 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 has 2 params (user_google_email, document_id) with 0% description coverage. Description explains document_id identifies the file, but user_google_email is not described, leaving it ambiguous. Adds partial meaning but not complete.

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

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

Description clearly states the tool retrieves content of Google Docs or Drive files (like .docx) using document_id. It distinguishes from siblings like get_drive_file_content and download_google_doc by specifying handling of both native Docs and Office files.

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

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

Description implies usage for reading doc content from Docs or Drive, but does not explicitly state when to use vs alternatives like get_drive_file_content or download_google_doc. No guidance on exclusions or when not to use.

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

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

With no annotations provided, the description carries full burden. It discloses export behavior for native Google apps, parsing for Office files, and fallback for other files. It also notes the return format includes a metadata header. This provides good transparency beyond just a generic 'get content' statement.

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 main sentence followed by bullet points for file handling. It is front-loaded with the core purpose. While a bit detailed, it efficiently covers multiple scenarios without unnecessary verbosity.

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 output schema exists (though not visible), the description covers return format as plain text with metadata header. It explains handling for various file types, which is comprehensive for a file content retrieval tool. It could mention authentication or size limits, but the core completeness is strong.

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 no descriptions (0% coverage), so the description adds meaning by labeling user_google_email as the user's Google email and file_id as the Drive file ID. These are minimal but sufficient given the self-explanatory parameter names.

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

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

The description clearly states it retrieves content of a specific Google Drive file by ID, supporting shared drives. The verb 'Retrieves' and resource 'content' are specific, and it distinguishes from siblings like get_drive_file_download_url or get_doc_content by focusing on content extraction.

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 detailed context on when to use the tool by explaining how different file types are handled (Google Docs, Office files, etc.). It implies use for text extraction but does not explicitly contrast with alternatives like get_doc_content or download_doc_tabs, so it's clear but not exhaustive.

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

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

With no annotations provided, the description carries the full burden. It discloses that the file is prepared and available via HTTP URL for 1 hour, and explains export behavior for native files. It does not mention any destructive effects or auth requirements beyond the email parameter, which is acceptable for a read-like 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 with a clear first sentence, followed by bullet points for export options. It is concise yet covers all necessary details without fluff. 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 and the presence of an output schema (as per context signals), the description adequately explains the return value (str with download URL and metadata) and the 1-hour availability. It could mention what 'file metadata' includes, but it is acceptable.

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?

Despite 0% schema coverage, the description adds full parameter semantics: required fields user_google_email and file_id are explained, and export_format is described with explicit options and default behaviors (PDF for Docs/Slides, XLSX for Sheets). This compensates completely for the lack of schema 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 'Gets a download URL for a Google Drive file' with specific verb and resource. It distinguishes from siblings like get_drive_file_content by explaining it returns a URL, not the content. The details on export formats for different file types further clarify purpose.

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

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

The description explains when to use this tool (to get a download URL) and notes that the URL is valid for 1 hour. However, it does not explicitly compare to alternatives like get_drive_file_content or mention when not to use this tool. Still, the context is clear enough for an agent.

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

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

No annotations provided, so description carries full burden. It discloses that it returns metadata including sharing status and URLs, but does not mention authentication needs, error cases, or any side effects. 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?

Description is concise: one sentence plus structured Args/Returns. Front-loaded with purpose. No wasted words, though the Args/Returns block could be slightly more integrated.

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 simple params and existence of output schema, description covers purpose and parameter meanings. It does not elaborate on output schema but that's acceptable. Overall complete for a straightforward tool.

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

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

Schema coverage is 0%, so description adds meaning. It explains user_google_email as the user's email and file_id as the file ID. However, it does not clarify why the email is needed (e.g., to check permissions for that user), leaving some ambiguity.

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 gets detailed metadata including sharing permissions, with a specific verb and resource. It distinguishes from siblings like get_drive_file_content (content) and check_drive_file_public_access (check public access).

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

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

No guidance on when to use this tool vs alternatives. Among siblings, there are more specific tools like check_drive_file_public_access, but the description does not provide context for 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?

No annotations provided, so the description must disclose behavioral traits. It does not mention whether the operation is read-only, requires specific permissions, or could modify sharing settings. The return mentions 'current sharing status' but doesn't explain side effects or prerequisites, leaving important ambiguity.

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

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

The description is short and uses a clean docstring format with Args and Returns sections. It avoids unnecessary words, though it repeats parameter names already in schema. Nonetheless, it communicates efficiently without 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 has only two parameters and an output schema, the description covers basic functionality and parameter semantics. However, missing usage context, behavioral disclosure, and prerequisites make it slightly incomplete for guiding an agent in a complex environment with many 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?

With 0% schema description coverage, the description adds meaningful explanations for both parameters: user_google_email as 'the user's Google email' and file_id as 'the ID of the file or folder.' These descriptions go beyond type information and clarify their roles, though email parameter could explain why it's needed.

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 retrieves the shareable link for a Google Drive file or folder. The verb 'Gets' and specific resource 'shareable link' make the purpose unambiguous, distinguishing it from siblings like get_drive_file_content or share_drive_file.

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

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

No guidance on when to use this tool versus alternatives. There are many related Drive tools (e.g., get_drive_file_content, check_drive_file_public_access, share_drive_file) but the description does not provide explicit when-to-use or when-not-to-use context, leaving the agent to infer 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?

Without annotations, the description comprehensively explains behavior: parameter interactions (ignoring time filters and other params when event_id provided), defaults, dependency of include_attachments on detailed, and output formatting. It could mention error handling or edge cases like no events found, but overall it is transparent.

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 one-line summary followed by parameter descriptions and return value. While it is relatively long, every sentence adds value. It could be slightly more concise, but the organization 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 the complexity of 9 parameters (1 required) and no annotations, the description is thorough. It explains all parameters, their interactions, defaults, and output format. It references list_calendars for calendar IDs, which helps with prerequisite knowledge. No major gaps are present.

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

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

The schema has 0% description coverage, so the description carries the full burden. It adds significant meaning: explains formats (RFC3339 for time_min/max), defaults (time_min defaults to current time when omitted), interactions (event_id overrides time filters), and the dependency chain for include_attachments. This far exceeds what the raw 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?

The description explicitly states it retrieves events from a specified Google Calendar, distinguishes between single event retrieval by ID and multiple events within a time range, and mentions keyword search. The verb 'retrieves' is clear, and the tool is distinct from siblings like create_event, modify_event, and delete_event.

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

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

The description provides guidance on when to use event_id vs time range, explains defaults for time_min (current time), and references list_calendars for obtaining calendar IDs. However, it lacks explicit when-not-to-use scenarios or comparisons with alternative retrieval tools, which would further aid 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 exist, so the description must bear the full burden of behavioral disclosure. It fails to mention permissions, side effects, error handling, or whether the operation is read-only. The agent gets no safety or behavioral clues.

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

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

The description is extremely concise, with the purpose front-loaded in the first line. Every sentence adds value, and the structure (Args/Returns) is clear. There is no unnecessary verbosity.

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 and the presence of an output schema, the description covers the essential purpose and parameters. However, it lacks usage context and behavioral details, making it merely adequate for a simple tool.

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

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

With 0% schema description coverage, the description adds basic meaning to both parameters: 'user_google_email' is identified as a Google email and 'form_id' as the form ID. However, it lacks additional context like format, source, or constraints, making it minimally adequate.

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 'Get a form', specifying the verb and resource. However, it does not explicitly differentiate it from sibling tools like 'get_form_response' or 'create_form', which could lead to confusion for the AI agent.

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

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

There is no guidance on when to use this tool versus alternatives. The description lacks any context about prerequisites, scenarios, or exclusions, leaving the agent without decision support.

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 fails to mention that the operation is read-only, has no side effects, or what happens if the response_id is invalid. It only describes parameters and return type.

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, includes an Args section and Returns, and is front-loaded with the main purpose. Every sentence is necessary, but the Args section could be more integrated.

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 retrieval tool with 3 parameters and an output schema, the description is mostly adequate but lacks important context like data source dependency and read-only nature. It is minimally 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 0%, so the description must compensate. It provides basic parameter labels but does not explain how to obtain form_id or response_id, nor their format 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 tool retrieves one response from a form, which distinguishes it from sibling tools like 'get_form' (form metadata) and 'list_form_responses' (list of responses).

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

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

No guidance on when to use this tool versus alternatives, such as needing to first list responses to obtain a response_id, or when not to use it.

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

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

No annotations are provided, so the description must bear the full burden. It discloses that content is downloaded and returned as base64-encoded metadata, but it does not mention side effects, authorization needs, or error conditions. The description is adequate but not comprehensive.

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

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

The description is succinct and front-loaded with the core purpose. Each sentence provides necessary information without redundancy, earning 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?

Despite no annotations, the description covers the tool's operation, parameters, and return format. It lacks prerequisites and error handling, but given that an output schema exists, the description is fairly complete for a straightforward download 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 adds meaning by naming and briefly explaining each parameter (message_id, attachment_id, user_google_email). It clarifies that user_google_email is required, which adds value beyond the schema's mandatory field list.

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