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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the workflow (sends cancel request, transitions to CANCELLED state, processing stops with possible delay, partial results may be available) and constraints (cannot cancel SUCCEEDED or FAILED jobs). It doesn't mention authentication needs or rate limits, but covers the essential mutation behavior and outcomes well.

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

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

The description is efficiently structured with clear sections (workflow, use case, note) and uses bullet-like formatting. Every sentence adds value, though it could be slightly more concise by combining some points. It's appropriately sized for the tool's complexity.

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

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

For a mutation tool with no annotations and no output schema, the description provides good contextual completeness. It explains the action, workflow, use cases, and constraints. While it doesn't detail the return format (e.g., what confirmation looks like), it covers the essential behavior and limitations adequately given the tool's single parameter and straightforward purpose.

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

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

Schema description coverage is 100%, with the single parameter 'batchName' documented as 'Batch job name/ID to cancel'. The description doesn't add any additional meaning about this parameter beyond what the schema provides, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the specific action ('CANCEL BATCH JOB - Request cancellation of running batch job') and distinguishes it from siblings like batch_delete (which likely removes completed jobs) or batch_get_status (which only checks status). The verb 'cancel' is precise and the resource 'batch job' is unambiguous.

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

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

The description explicitly states when to use this tool ('Stop long-running job due to errors, changed requirements, or cost management') and when not to use it ('Cannot cancel SUCCEEDED or FAILED jobs'). This provides clear context and exclusions, helping the agent choose this over alternatives like batch_delete for active jobs.

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

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

With no annotations provided, the description carries full burden and delivers substantial behavioral context: it discloses cost implications (50% cheaper), turnaround time (~24 hours), workflow dependencies, file size constraints, and what the tool returns (batch job ID and initial status). It doesn't mention error handling, rate limits, or authentication requirements, but provides more behavioral detail than most descriptions without annotations.

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

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

The description is efficiently structured with clear sections (COST, TURNAROUND, WORKFLOW, SUPPORTS, Returns) using concise bullet-like formatting. Every sentence adds value: cost/timing benefits, workflow steps, constraints, and return values. No wasted words while maintaining excellent readability.

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

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

For a complex batch creation tool with 6 parameters, nested objects, and no output schema, the description provides exceptional completeness. It covers purpose, workflow integration, cost/timing, constraints, usage patterns, and return values. Given the absence of annotations and output schema, it successfully compensates by providing the contextual information an agent needs to use this tool effectively within the broader batch processing ecosystem.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds some semantic context by explaining the two primary usage patterns (inline requests <20MB vs. file-based JSONL for large batches) and referencing the workflow, but doesn't provide additional parameter meaning beyond what's in the schema descriptions. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the specific action ('CREATE BATCH JOB'), resource ('async content generation batch job with Gemini'), and distinguishes it from siblings by focusing on content generation (vs. embeddings, processing, or other batch operations). It explicitly mentions the workflow and cost/turnaround characteristics that differentiate it from standard API calls.

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

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

The description provides explicit guidance on when to use this tool (for async content generation with cost/turnaround benefits), when to use alternatives (inline vs. file-based approaches), and references sibling tools for the complete workflow (batch_ingest_content, upload_file, batch_get_status, batch_download_results). It clearly outlines the multi-step process and constraints (<20MB for inline).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: it's an async batch job (not immediate), mentions cost ('50% cheaper than standard API'), specifies the model and dimensions, and outlines the multi-step workflow. However, it doesn't mention rate limits, error handling, or job duration expectations.

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 clear sections (COST, MODEL, WORKFLOW, TASK TYPES) and uses bullet-like numbering for the workflow. It's appropriately sized for a complex tool, though some sentences could be more concise (e.g., the workflow list is verbose but necessary).

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

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

For a complex batch processing tool with 6 parameters, 100% schema coverage, and no output schema, the description does a good job of providing context. It explains the async nature, cost benefits, model details, and full workflow. However, it doesn't describe the output format or error responses, which would be helpful given the lack of output schema.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some context: it mentions the model (gemini-embedding-001 with 1536 dimensions) and references batch_query_task_type for task type guidance, but doesn't provide additional parameter semantics beyond what's already in the 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 tool's purpose: 'CREATE EMBEDDINGS BATCH JOB - Create async embeddings generation batch job.' It specifies the exact action (create async batch job) and resource (embeddings), and distinguishes it from siblings like batch_ingest_embeddings (for content conversion) and batch_get_status (for monitoring).

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 workflow guidance: 'WORKFLOW: 1) Prepare content (use batch_ingest_embeddings for conversion), 2) Select task type (use batch_query_task_type if unsure), 3) Upload file, 4) Call batch_create_embeddings, 5) Monitor with batch_get_status, 6) Download with batch_download_results.' It names specific alternative tools for different steps and clarifies when to use them.

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

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

With no annotations provided, the description carries full burden and does well by disclosing the workflow steps, irreversible nature, and data loss risks. It mentions validation, API deletion, and internal tracking removal, though it doesn't cover error handling or authentication requirements.

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

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

The description is well-structured with clear sections (workflow, use case, warning) and front-loaded key information. It's appropriately sized, though slightly verbose with the workflow details that could be condensed.

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

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

For a destructive tool with no annotations or output schema, the description provides good context about the irreversible operation, workflow, and use cases. It could improve by mentioning error conditions or response format, but it's largely complete for agent understanding.

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

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

Schema description coverage is 100% with one parameter clearly documented. The description adds no additional parameter semantics beyond what's in the schema, so it meets the baseline of 3 for adequate coverage without extra value.

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

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

The description explicitly states the verb ('DELETE') and resource ('BATCH JOB'), and distinguishes it from siblings like batch_cancel or batch_download_results by specifying it's a permanent deletion operation. The title 'DELETE BATCH JOB' reinforces this clarity.

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 usage guidance with 'USE CASE: Clean up completed/failed jobs, manage job history, free storage' and warns 'Recommended to download results before deletion.' It clearly differentiates from batch_download_results and batch_cancel by focusing on permanent cleanup.

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

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

With no annotations provided, the description carries the full burden and does so well. It discloses key behavioral traits: the multi-step workflow (status check, download, parse, save), prerequisites (job must be SUCCEEDED), side effects (saves to local file), and return format (array with keys, responses, metadata). It lacks details on error handling or rate limits, but covers essential operations.

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

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

The description is appropriately sized and front-loaded with the core purpose. The workflow breakdown is useful but slightly verbose; every sentence earns its place by clarifying steps and returns, though it could be more streamlined without losing clarity.

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

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

Given no annotations and no output schema, the description does a good job covering complexity: it explains the workflow, prerequisites, return values, and side effects. However, it lacks details on error cases (e.g., if job fails) or file naming conventions, leaving minor gaps for a tool with significant behavioral steps.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description adds minimal value beyond the schema: it mentions outputLocation defaults to current working directory (implied in schema) and ties batchName to batch_create, but does not provide additional syntax, format, or constraints. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the specific action (download and parse results from completed batch job) and distinguishes it from siblings like batch_get_status (which only checks status) or batch_create (which creates jobs). It specifies the resource (batch job results) and the multi-step workflow, making the purpose unambiguous.

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

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

The description provides clear context for when to use this tool: after a batch job has completed with SUCCEEDED status. It implicitly suggests alternatives like batch_get_status for checking status without downloading, but does not explicitly name when-not scenarios or compare to all siblings like batch_cancel or batch_delete.

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

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

With no annotations provided, the description carries the full burden and does well by detailing the job states (PENDING, RUNNING, etc.), the workflow steps, and the polling behavior. It explains what the tool returns (current state, progress stats, completion info) and the auto-polling mechanism. Minor gap: doesn't mention error handling 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?

Well-structured with clear sections (STATES, WORKFLOW, USAGE) and front-loaded purpose. Slightly verbose with some redundancy (e.g., 'optional auto-polling' then 'Optionally enable polling'), but every sentence adds value. 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?

For a tool with no annotations and no output schema, the description provides substantial context: states, workflow, usage guidance, and behavioral details. It adequately compensates for the lack of structured fields, though it could benefit from explicitly mentioning the return format or error cases.

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

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

Schema description coverage is 100%, so the schema already fully documents all parameters. The description adds some context by mentioning 'batch job name/ID' and 'auto-polling', but doesn't provide additional semantic meaning beyond what's in the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('GET BATCH JOB STATUS - Check status of running batch job') and distinguishes it from siblings like batch_cancel, batch_create, etc. It specifies the resource (batch job) and verb (check status) with precision.

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

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

Explicit guidance is provided: 'USAGE: Pass job name from batch_create response. Enable autoPoll for hands-off waiting.' This tells the agent exactly when to use this tool (after batch_create) and how to configure it for different scenarios (hands-off vs manual checking).

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

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

With no annotations provided, the description carries the full burden and does well by detailing the multi-step workflow, supported formats, and return values. It discloses behavioral traits like format detection, script generation, and validation, though it lacks specifics on error handling, rate limits, or permissions required.

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

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

The description is appropriately sized and front-loaded with 'INTELLIGENT CONTENT INGESTION', followed by a structured workflow and support details. It's efficient with no wasted sentences, though the capitalization and formatting could be slightly more polished for readability.

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

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

Given the tool's complexity (multi-step conversion), no annotations, and no output schema, the description is fairly complete by explaining the workflow, supported formats, and return values. However, it could improve by detailing error cases or output schema specifics to fully compensate for the lack of structured data.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds context by mentioning 'auto-generated' for outputFile and 'analysis/extraction scripts' for generateScripts, but it doesn't provide additional meaning beyond what's in the schema, such as file path formats or script details.

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

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

The description clearly states the tool's purpose with specific verbs ('analyzes', 'converts', 'detects', 'writes', 'validates') and resources ('content file', 'JSONL'), distinguishing it from sibling tools like batch_create_embeddings or batch_process by focusing on content ingestion and format conversion rather than batch management or embeddings processing.

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 its workflow and supported formats, suggesting it's for converting various file types to JSONL, but it doesn't explicitly state when to use this tool versus alternatives like batch_process or upload_file, nor does it provide exclusions or prerequisites for usage.

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

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

With no annotations provided, the description carries full burden and does well by describing the multi-step workflow (analyzes, extracts, formats, validates) and optimization for specific formats. It discloses the output format (JSONL file) and how it's structured (with task_type embedded). It doesn't mention error handling, performance characteristics, or file size limits, which keeps it from a perfect score.

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

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

The description is efficiently structured with clear sections (WORKFLOW, OPTIMIZED FOR, RETURNS), uses bullet-like numbering for steps, and every sentence adds value. No redundant information or wasted words - it's front-loaded with the core purpose and progressively adds details.

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

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

For a tool with 4 parameters, 100% schema coverage, and no output schema, the description provides good context about the workflow, format optimization, and output usage. It explains what the tool produces and how it connects to batch_create_embeddings. The main gap is lack of explicit error handling or limitations information, preventing a perfect score.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some value by mentioning 'auto-detected if not provided' for textField (implied in schema but reinforced) and referencing batch_query_task_type for taskType uncertainty. However, it doesn't provide significant additional parameter semantics beyond what the schema already documents.

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

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

The description clearly states the tool's purpose with specific verbs ('analyzes', 'extracts', 'formats', 'validates') and resources ('embeddings batch processing', 'JSONL file'). It distinguishes from sibling tools by specifying this is for embeddings processing rather than general content ingestion (batch_ingest_content) or embeddings creation (batch_create_embeddings).

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 usage guidance: 'OPTIMIZED FOR: Text extraction from various formats (CSV columns, JSON fields, TXT lines, MD sections)' tells when to use it. 'RETURNS: JSONL file ready for batch_create_embeddings' indicates the next step in workflow. It also distinguishes from batch_query_task_type with 'Use batch_query_task_type if unsure' for taskType parameter.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the complete 6-step workflow including ingestion, conversion, upload, job creation, polling, and result download/parsing. It mentions polling behavior ('Polls until complete') and return values ('RETURNS: Final results with metadata'). However, it doesn't specify error handling, rate limits, or authentication requirements, leaving some behavioral aspects unclear.

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

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

The description is appropriately sized and well-structured with clear sections (workflow steps, best for, returns, alternatives). Every sentence adds value, though it could be slightly more concise by combining some workflow steps. The information is front-loaded with the main purpose immediately stated.

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

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

For a complex 5-parameter batch processing tool with no annotations and no output schema, the description provides substantial context about the workflow, return values, and alternatives. It covers the main behavioral aspects well, though additional details about error handling or output format would make it more complete. The description compensates reasonably for the lack of structured metadata.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions the workflow steps but doesn't explain how parameters like 'inputFile' or 'config' relate to those steps. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool performs 'End-to-end content generation batch processing' with a detailed 6-step workflow. It specifically distinguishes itself from sibling tools by being a 'simple one-call solution' versus the individual tools like batch_ingest_content, batch_create, etc. The verb 'processes' and resource 'batch workflow' are specific and well-defined.

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

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

The description explicitly states when to use this tool ('BEST FOR: Users who want simple one-call solution') and when to use alternatives ('For more control, use individual tools...'). It names specific sibling tools (batch_ingest_content, batch_create, batch_get_status, batch_download_results) as alternatives, providing clear guidance on tool selection.

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

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

With no annotations provided, the description carries full burden and does well by detailing the 7-step workflow including interactive prompting, polling behavior, and file operations. It discloses that the tool will 'Queries user for task type (or auto-recommends)' and 'Polls until complete,' which are important behavioral traits not evident from the schema alone.

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

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

The description is well-structured with clear sections (workflow steps, best for, returns) and front-loaded with the key purpose. It could be slightly more concise by combining some workflow steps, but overall it's efficient with no wasted 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?

For a complex 5-parameter tool with no annotations and no output schema, the description does well by explaining the complete workflow, return format (embeddings array with metadata), and usage context. It could benefit from more detail about error handling or limitations, but covers the essential 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 100%, so the baseline is 3. The description doesn't add significant parameter semantics beyond what's already in the schema descriptions, though it does provide context about the overall workflow that helps understand parameter roles.

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

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

The description clearly states the tool performs 'End-to-end embeddings batch processing' with a detailed 7-step workflow, distinguishing it from simpler sibling tools like batch_create_embeddings or batch_ingest_content. It specifies the exact scope as a complete workflow for embeddings generation.

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

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

The description explicitly states 'BEST FOR: Simple one-call embeddings generation,' providing clear guidance on when to use this tool versus alternatives. It distinguishes this comprehensive workflow from more granular sibling tools like batch_create or batch_download_results.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the interactive and recommendation-based behavior, including optional analysis and AI-driven suggestions, but lacks details on permissions, rate limits, or error handling. It does not contradict annotations, as none are given.

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 sections like 'INTERACTIVE TASK TYPE SELECTOR,' 'WORKFLOW,' and 'TASK TYPES,' making it front-loaded and easy to scan. It is appropriately sized but includes some redundancy (e.g., listing all task types might be verbose if not essential), though each sentence adds context.

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

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

Given the complexity of an interactive selector with no annotations and no output schema, the description is moderately complete. It covers the workflow and task types but lacks details on output format, error cases, or integration with sibling tools. For a tool with 2 parameters and behavioral nuances, it should provide more context on what is returned or how failures are handled.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the purpose of parameters indirectly: 'context' is linked to 'use case' in the workflow, and 'sampleContent' is tied to 'analyzes sample content.' However, it does not provide detailed semantics beyond what the schema descriptions already cover, such as format examples for sampleContent.

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

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

The description clearly states the tool's purpose as an 'INTERACTIVE TASK TYPE SELECTOR' that 'Helps choose optimal embedding task type with recommendations,' specifying the verb (select/choose) and resource (task type). It distinguishes itself from siblings like batch_create_embeddings or batch_process by focusing on selection/recommendation rather than creation or processing, with no tautology present.

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

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

The description provides clear context for usage through the 'WORKFLOW' section, outlining steps like analyzing sample content and showing task types. However, it does not explicitly state when not to use this tool or name specific alternatives among siblings, such as batch_process_embeddings for actual processing, leaving some guidance implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: file handling (server caches files, auto-retrieves missing ones), conversation continuity (via conversationId), return values (response text, token usage, conversation ID), and implementation details (files passed as direct objects, not fileData structures). It doesn't mention rate limits or error handling, but covers most operational aspects well.

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

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

The description is appropriately sized and front-loaded with the core purpose. It uses clear sections (TYPICAL USE, SCALES TO, WORKFLOW, RETURNS) for organization. Some sentences could be more concise (e.g., 'The server handles file object caching and proper API formatting' could be simplified), but overall it's 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?

Given the tool's complexity (6 parameters, file handling, conversation management) and lack of both annotations and output schema, the description does a good job covering most essential context. It explains the workflow, return values, and behavioral details. The main gap is the absence of an output schema, but the description compensates by listing return values (response text, token usage, conversation ID).

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds some context about fileUris (requiring upload first, typical file counts) and conversationId (for continuity), but doesn't provide significant additional semantic meaning beyond what's in the schema descriptions. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('SEND MESSAGE TO GEMINI'), resource ('Gemini'), and scope ('with optional files for multimodal analysis'). It distinguishes itself from sibling tools like upload_file or generate_images by focusing on the core chat interaction with the AI model.

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

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

The description provides explicit guidance on when and how to use this tool, including a workflow (upload files first, then pass URIs), typical use cases (0-2 files for code review, document analysis), and scaling options (40+ files for comprehensive analysis). It references specific sibling tools (upload_file, upload_multiple_files) as alternatives for file handling.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: the irreversible nature of the operation ('Irreversible operation affecting all uploaded files'), the scope ('ALL files from Gemini File API associated with current API key'), and the return format ('Count of deleted vs failed deletions with detailed lists'). However, it lacks details on error handling 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 and front-loaded with the core action ('BULK DELETE ALL FILES'), followed by details on behavior, return values, use cases, and warnings. Each sentence adds value, but it could be slightly more concise by combining some clauses.

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 high complexity (destructive bulk operation) and lack of annotations or output schema, the description does a good job covering purpose, usage, behavior, and warnings. However, it could be more complete by specifying authentication requirements or potential errors, though the absence of an output schema is partially mitigated by describing the return format.

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 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's behavior and context without redundant parameter details, earning a baseline score of 4 for zero parameters.

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

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

The description explicitly states the tool's purpose with specific verbs ('BULK DELETE ALL FILES', 'Removes ALL files', 'Clears entire cache') and clearly distinguishes it from sibling tools like 'delete_file' (single file) and 'batch_delete' (batch operations). It directly addresses what the tool does without ambiguity.

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

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

The description provides explicit usage guidelines with 'USE CASE: Complete cleanup after batch processing, reset environment, clear storage quota', indicating when to use this tool. It also includes a 'WARNING' about irreversibility, which helps differentiate it from less destructive alternatives like 'delete_file' or 'clear_conversation'.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the destructive behavior ('Deletes'), side effects ('Frees memory and resets context'), and output expectations ('Returns confirmation or 'not found' message'). However, it lacks details on permissions, rate limits, or error handling, preventing a perfect score.

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

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

The description is front-loaded with the core action, followed by usage and context, all in three efficient sentences. Minor improvements could include bullet points for clarity, but it avoids redundancy and wastes no 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 1 parameter with full schema coverage and no output schema, the description is mostly complete: it covers purpose, usage, behavior, and parameter context. It could enhance completeness by specifying output format details or error scenarios, but it adequately supports tool selection and invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the parameter's source ('conversationId from start_conversation or chat response'), which provides context beyond the schema's generic description. It doesn't fully detail format or constraints, but this extra guidance merits a score above baseline.

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

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

The description clearly states the specific action ('Deletes specified conversation session and all associated message history') and resource ('conversation history'), distinguishing it from siblings like 'cleanup_all_files' or 'delete_file' which handle different resources. The title-like opening 'CLEAR CONVERSATION HISTORY' reinforces the purpose without being tautological.

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

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

Explicit guidance is provided: 'Use when switching topics or cleaning up after completion' specifies when to use it, and 'Pass conversationId from start_conversation or chat response' indicates prerequisites. It distinguishes from alternatives by focusing on conversation history, not files or batches.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates critical traits: the operation is permanent ('cannot be undone'), immediate ('Immediate deletion'), and has side effects ('clears from cache'). It also mentions the auto-delete policy ('Files auto-delete after 48 hours if not manually removed'), adding valuable context beyond basic functionality.

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

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

The description is well-structured and front-loaded with the core action. Each sentence adds value: the first defines the tool, the second specifies usage, and the third provides use cases and notes. However, the 'NOTE' about auto-delete, while useful, could be integrated more smoothly, and some phrasing ('DELETE FILE FROM GEMINI') is slightly redundant.

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 operation with no annotations or output schema), the description is complete enough. It covers purpose, behavior, usage guidelines, and critical warnings, addressing all necessary aspects for safe and effective use without needing to explain return values or rely on structured fields.

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

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

Schema description coverage is 100%, with the parameter 'fileUri' fully documented in the schema. The description adds minimal semantic context by noting 'Pass fileUri from upload or list_files', which hints at the parameter's source but does not provide additional syntax or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('permanently removes file') and resource ('from Gemini File API and clears from cache'), distinguishing it from siblings like 'get_file' (retrieval) and 'list_files' (listing). It explicitly identifies the tool's destructive nature, making its purpose unambiguous.

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

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

The description provides clear usage context ('Clean up after processing, manage storage quota, remove sensitive data') and notes prerequisites ('Pass fileUri from upload or list_files'). However, it does not explicitly mention when NOT to use it or name specific alternatives among siblings (e.g., 'cleanup_all_files' for bulk deletion), which prevents a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: images are auto-saved to outputDir, returns an array of file paths, includes cost (~1,290 tokens per image), and adds a SynthID watermark. It also covers models and aspect ratios, though it lacks details on error handling 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 sections like CAPABILITIES, MODELS, WORKFLOW, and RETURNS, making it easy to scan. It is appropriately sized, but some sentences could be more concise, such as the workflow steps which are somewhat verbose. Overall, it front-loads key information efficiently.

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

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

Given the complexity of the tool (7 parameters, no output schema, no annotations), the description is largely complete. It covers purpose, usage, behaviors, and returns, though it could benefit from more detail on error cases or output structure. The absence of an output schema is partially compensated by describing the return as an array of file paths.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema, such as mentioning that inputImageUri is for editing and outputDir has a default, but does not provide significant additional semantics or usage examples for the parameters.

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

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

The description clearly states the tool's purpose with specific verbs ('generate or edit images') and resources ('images using Gemini image models'), distinguishing it from sibling tools which focus on batch operations, file management, and chat. It explicitly lists capabilities like text-to-image generation and image editing, making the purpose unambiguous.

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

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

The description provides clear context for when to use this tool, such as for text-to-image generation or editing existing images, and outlines a workflow with optional parameters. However, it does not explicitly state when not to use it or name alternatives among sibling tools, which are unrelated to image generation.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly describes the tool's behavior: retrieving metadata from Gemini API, updating cache, and automatically adding to cache if missing. It mentions the return format ('Complete file info including uri, displayName...') and the caching side effect. However, it doesn't disclose potential rate limits, authentication needs, or error conditions, which would be helpful for a complete behavioral picture.

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

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

The description is efficiently structured with clear sections: purpose statement, usage instructions, return details, and use cases. Every sentence adds value without redundancy. It's front-loaded with the core functionality ('GET FILE METADATA & UPDATE CACHE') and maintains appropriate length for the tool's complexity.

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 no annotations and no output schema, the description does a good job explaining what the tool does, when to use it, and what it returns. It covers the caching behavior and use cases. However, for a tool that interacts with an external API (Gemini), additional context about error handling or rate limiting would make it more complete, though the current description is substantially adequate.

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

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

Schema description coverage is 100%, so the schema already documents the single parameter 'fileUri' with its description. The description adds minimal value beyond the schema by mentioning 'Pass fileUri from upload response or list_files', which provides context about where to obtain the parameter value. This meets the baseline of 3 when schema coverage is high.

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

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

The description clearly states the tool's purpose with specific verbs ('retrieves', 'updates') and resources ('metadata for specific file', 'cache'). It distinguishes from siblings like list_files (which lists multiple files) and upload_file (which uploads rather than retrieves). The phrase 'GET FILE METADATA & UPDATE CACHE' directly communicates the dual functionality.

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

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

The description provides explicit guidance on when to use this tool: 'USE CASE: Verify file state, check expiration, refresh cache entry.' It also specifies when to use it versus alternatives by stating 'Pass fileUri from upload response or list_files', indicating it's for specific files rather than listing all files. The tool name 'get_file' versus 'list_files' further differentiates usage contexts.

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

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

With no annotations provided, the description carries the full burden. It discloses key behaviors: 'Updates internal cache with latest file states', returns specific fields including 'cachedCount indicating files ready for immediate use', and mentions the '20GB project limit' for storage auditing. However, it doesn't cover error conditions 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 appropriately sized and front-loaded with the core purpose. Every sentence adds value: purpose, behavior, returns, and usage guidelines. It could be slightly more structured with bullet points but remains 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 no annotations and no output schema, the description does well by explaining the return structure ('Array of files with uri, displayName...') and usage context. It covers the tool's purpose, behavior, and practical applications adequately, though it lacks details on error handling or pagination beyond pageSize.

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

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

Schema description coverage is 100% (pageSize parameter fully documented in schema), so baseline is 3. The description doesn't add any parameter-specific information beyond what the schema provides, but it doesn't need to compensate for gaps.

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

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

The description clearly states the specific verb ('LIST ALL UPLOADED FILES', 'Retrieves metadata') and resource ('files currently in Gemini File API'), distinguishing it from siblings like get_file (single file) or delete_file (mutation). It explicitly mentions the scope ('all files associated with API key').

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 usage scenarios: 'Check file availability before chat, monitor upload status, audit storage usage (20GB project limit)'. It distinguishes when to use this tool (for listing all files) versus alternatives like get_file for single files or cleanup_all_files for deletion.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it creates a new context, generates IDs if not provided, stores message history, and returns a conversationId for continuity. However, it lacks details on potential errors, session limits, or persistence duration, which would be useful for a tool managing conversational state.

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 purpose in the first sentence and efficiently structured into two sentences that cover initialization, behavior, and usage. While slightly verbose with capitalized headings, every sentence adds necessary information without waste, making it highly effective 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?

For a tool with no annotations, no output schema, and a simple input schema, the description is quite complete. It explains the tool's role in a multi-turn chat system, its behavior, and integration with sibling tools. However, it could improve by mentioning output specifics (e.g., format of conversationId) or error cases, given the lack of structured output documentation.

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

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

Schema description coverage is 100%, so the schema already documents the single optional 'id' parameter. The description adds value by explaining the parameter's purpose ('Generates unique ID if not provided') and its role in the workflow, but does not provide additional syntax or format details beyond what the schema implies. Given the single parameter and high coverage, this exceeds the baseline of 3.

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

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

The description clearly states the tool's purpose with specific verbs ('INITIALIZE', 'Creates', 'Generates', 'Stores', 'Returns') and resources ('conversation session', 'new conversation context', 'unique ID', 'message history', 'conversationId'). It distinguishes from sibling tools by explicitly mentioning its role in the Gemini chat workflow and referencing the 'chat' tool for continuation.

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

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

The description provides explicit guidance on when to use this tool: 'Call before first chat or to start fresh context.' It also specifies how to use it in conjunction with alternatives: 'Pass returned ID to chat tool's conversationId parameter for continuation,' clearly differentiating it from the 'chat' and 'clear_conversation' siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behavioral traits: automatic retry and state monitoring, processing time (10-30 seconds), auto-deletion after 48 hours, and the return of specific data fields. However, it doesn't mention error handling or rate limits, which keeps it from a perfect score.

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 clear sections (BEST FOR, WORKFLOW, RETURNS) and avoids unnecessary fluff. However, it could be slightly more concise by integrating some points more tightly, and the all-caps 'UPLOAD SINGLE FILE' is somewhat redundant with the tool name.

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 no annotations and no output schema, the description does an excellent job covering key aspects: purpose, usage guidelines, behavioral traits, and return values. It compensates well for the lack of structured output schema by explicitly listing return fields. Minor gaps in error handling prevent a perfect score.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any meaningful parameter-specific information beyond what's in the schema (e.g., it mentions auto-detected MIME type but the schema already states this). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('UPLOAD SINGLE FILE'), target resource ('to Gemini'), and distinguishes it from sibling tools by explicitly mentioning 'upload_multiple_files' as an alternative for 2+ files. It provides a verb+resource+scope combination that is precise and differentiated.

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

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

The description provides explicit guidance on when to use this tool ('BEST FOR: Single documents, images, or code files for immediate analysis') and when to consider alternatives ('For 2+ files, consider upload_multiple_files for efficiency'). It also outlines the workflow context, making usage scenarios clear.

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

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

With no annotations, the description carries full burden and provides rich behavioral details: automatic retry (3 attempts), parallel uploads (5 concurrent default), processing state monitoring (waits for ACTIVE state), performance estimates (2 files = ~30 seconds, etc.), and return values (URIs, error details for failures). It doesn't mention authentication or rate limits, but covers key operational traits.

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

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

Well-structured with sections (TYPICAL USE, SCALES TO, FEATURES, WORKFLOW, PERFORMANCE) and front-loaded key information. Some redundancy exists (e.g., 'UPLOAD MULTIPLE FILES EFFICIENTLY' could be tighter), but most sentences earn their place by adding 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 no annotations and no output schema, the description provides comprehensive context: purpose, usage scenarios, behavioral traits, performance estimates, and return values. It adequately compensates for the lack of structured fields, though it could mention error handling or prerequisites more explicitly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds context about the workflow ('Provide array of file paths') and implies batch optimization, but doesn't add significant semantic details beyond what the schema provides. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool uploads multiple files efficiently with smart parallel processing, distinguishing it from the sibling 'upload_file' tool for single files. It specifies the verb 'upload' and resource 'multiple files' with scope (2-40+ 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?

Explicit guidance is provided: use for 2-10 files for multi-document analysis, code reviews, or comparative tasks; scales to 40+ files for dataset processing; and explicitly states 'Use upload_file for single files instead,' clearly differentiating from the sibling tool.

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