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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Get metrics data' implies a read-only operation, but the description doesn't address authentication requirements (despite 3 auth parameters), rate limits, what specific metrics are returned, or whether this is a real-time or historical query. For a tool with 8 parameters including multiple auth options, this is insufficient.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information.

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

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

For a tool with 8 parameters (7 required) and no output schema, the description is inadequate. It doesn't explain what metrics are returned, how they're formatted, or why multiple authentication parameters exist. With no annotations and complex parameter requirements, the description should provide more context about the tool's behavior and output.

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 all parameters are documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema. The baseline score of 3 reflects adequate coverage through the schema alone, though the description adds no additional value.

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

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

The description clearly states the verb 'Get' and resource 'metrics data for Google Apps Script projects', making the purpose unambiguous. However, it doesn't differentiate this tool from sibling tools like 'script_projects_get' or 'script_projects_deployments_get', which also retrieve information about scripts.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools that retrieve script-related data (e.g., 'script_projects_get', 'script_projects_deployments_get'), there's no indication of when metrics data is needed versus other script information.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions listing information but fails to describe key traits like whether this is a read-only operation, if it supports pagination (implied by 'pageToken' in schema but not explained), rate limits, authentication needs, or what the output format looks like. This leaves significant gaps for an agent to understand how to interact with the tool effectively.

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

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

The description is a single, efficient sentence that front-loads the core action ('List information about a script's executed processes'). There is no wasted verbiage, making it easy for an agent to parse quickly and understand the basic intent without unnecessary details.

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

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

Given the complexity of 10 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like pagination, filtering logic, or response structure, which are critical for an agent to use this tool correctly. The schema covers parameters well, but the overall context lacks sufficient guidance for safe and effective 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?

The schema description coverage is 100%, with all 10 parameters well-documented in the schema. The description adds no additional meaning beyond what the schema provides, such as explaining filter interactions or parameter constraints. Since the schema does the heavy lifting, a baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the verb ('List') and resource ('script's executed processes'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'script_processes_list' or 'get_script_metrics', which appear to have overlapping functionality, leaving some ambiguity about when to choose this specific tool.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'script_processes_list' or 'get_script_metrics'. It lacks context about prerequisites, such as needing a valid script ID, or exclusions, leaving the agent to infer usage from the schema alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a list operation but doesn't mention whether it's paginated (though 'pageToken' and 'pageSize' parameters suggest it is), what authentication is required, rate limits, or what the output format looks like. For a tool with 13 parameters and no output schema, this is insufficient.

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

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

The description is a single, clear sentence that states exactly what the tool does without any unnecessary words. It's appropriately sized and front-loaded with the essential information.

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

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

For a tool with 13 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain the relationship between parameters, how filtering works, what the output contains, or provide any context about the processes being listed. The agent would need to infer too much from parameter names alone.

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 13 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions, so it meets the baseline expectation without adding 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 clearly states the action ('List') and resource ('processes for a Google Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate this tool from the sibling 'list_script_processes' which appears to serve a similar function, preventing a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'list_script_processes' or 'get_script_metrics'. There's no mention of prerequisites, typical use cases, or when other tools might be more appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Create' implies a write operation, the description doesn't address permissions required, whether this is idempotent, what happens on failure, or what the response contains (e.g., project ID). This leaves significant gaps for a mutation tool.

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

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

The description is a single, efficient sentence that directly states the tool's purpose with zero wasted words. It's appropriately sized and front-loaded, making it easy to understand at a glance.

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 creation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens after creation (e.g., returns a project ID), potential errors, or how it integrates with sibling tools. Given the complexity of script projects and the rich sibling toolset, more context is needed.

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 both parameters clearly documented in the schema. The description adds no additional parameter information beyond what's in the schema, so it meets the baseline score 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 verb ('Create') and resource ('new Google Apps Script project'), making the purpose immediately understandable. However, it doesn't distinguish this tool from sibling tools like 'script_projects_versions_create' or 'script_projects_deployments_create', which also create related resources but not the project itself.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a parent project), when not to use it, or how it differs from sibling tools like 'script_projects_versions_create' that might be more appropriate in certain 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?

No annotations are provided, so the description carries full burden. While 'creates' implies a write operation, it doesn't disclose behavioral traits like whether this requires specific permissions, what happens if deployment fails, whether it's idempotent, or what the typical response looks like. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with every word 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?

Given this is a mutation tool with no annotations, no output schema, and siblings that suggest complex workflows (e.g., versions, updates, deletions), the description is incomplete. It doesn't address what happens after creation, error conditions, or how this fits into the broader deployment lifecycle, leaving significant gaps for an AI agent.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters with basic descriptions. The description adds no additional meaning about parameters beyond what's in the schema, such as explaining relationships between them (e.g., manifestFileName must match an existing file) or providing examples. 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 verb ('creates') and resource ('deployment of an Apps Script project'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its sibling 'script_projects_versions_create' which also creates something related to Apps Script projects, nor does it specify what type of deployment this creates (e.g., web app, API executable).

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'script_projects_deployments_update' and 'script_projects_versions_create', there's no indication of prerequisites (e.g., needing an existing script project), sequencing (e.g., create version first), or when to choose this over other deployment-related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool performs a deletion, implying it's destructive, but doesn't clarify if the deletion is permanent, reversible, requires specific permissions, affects associated resources, or has side effects like breaking linked scripts. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the key action ('Delete'), making it easy to scan and understand immediately.

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

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

For a destructive tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion (e.g., success confirmation, error handling), whether it affects project versions or runs, or any dependencies. Given the complexity of deployments in a scripting context, more behavioral context is needed.

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 100% description coverage, with both parameters ('scriptId' and 'deploymentId') clearly documented. The description doesn't add any semantic context beyond what the schema provides, such as where to find these IDs or format requirements. Baseline 3 is appropriate since 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 action ('Delete') and the resource ('a deployment of an Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling deletion tools (none are listed) or other destructive operations like 'update_script_content' that might also modify deployments.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a deployment ID from 'script_projects_deployments_list'), when not to use it (e.g., for active deployments), or how it differs from related tools like 'script_projects_deployments_update' or 'update_script_content'.

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 for behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this requires authentication, returns specific data formats, has rate limits, or handles errors. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately front-loaded and earns its place by clearly communicating the core functionality.

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

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

Given the lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what a 'deployment' entails in this context, what data is returned, or any prerequisites for successful execution. For a retrieval tool in a complex domain (Apps Script projects), more contextual information would be helpful.

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

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

Schema description coverage is 100%, with both parameters clearly documented in the schema. The description doesn't add any meaningful parameter context beyond what the schema already provides, so it meets the baseline expectation without compensating 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 clearly states the action ('Get') and resource ('deployment of an Apps Script project'), making the purpose immediately understandable. However, it doesn't distinguish this tool from potential siblings like 'script_projects_deployments_list' or 'script_projects_versions_get' which might retrieve related but different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'script_projects_deployments_list' (likely for listing multiple deployments) and 'script_projects_get' (for retrieving project metadata), the agent must infer usage context without explicit direction.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it 'Lists' deployments, implying a read-only operation, but doesn't describe pagination behavior (implied by parameters), return format, error conditions, or authentication requirements. The description is minimal and lacks essential operational context.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and efficiently communicates the essential action without unnecessary elaboration.

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 5 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what a 'deployment' entails in this context, the structure of returned data, pagination behavior, or error handling. The minimal description leaves too many operational questions unanswered.

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 fully documents all 5 parameters. The description adds no additional parameter semantics beyond implying 'scriptId' is required (stated in schema). Baseline 3 is appropriate when schema does all the work, though the description could have explained relationships between parameters like pagination.

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 ('Lists') and resource ('deployments of an Apps Script project'), making the purpose immediately understandable. It distinguishes from siblings like 'script_projects_deployments_get' (singular) and 'script_projects_deployments_create' (creation), but doesn't explicitly contrast with 'script_projects_versions_list' which lists versions rather than deployments.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid scriptId), compare to similar tools like 'script_projects_versions_list', or indicate scenarios where deployments listing is appropriate over other operations.

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

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

With no annotations provided, the description carries full burden but lacks behavioral details. It states 'Updates' implying mutation, but doesn't disclose permissions needed, whether changes are reversible, rate limits, or what the response looks like (no output schema). This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero waste, front-loading the core action and resource. It's appropriately sized for the tool's complexity, making it easy to parse quickly.

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

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

Given a mutation tool with no annotations, 67% schema coverage, no output schema, and nested objects, the description is incomplete. It doesn't address behavioral aspects (e.g., side effects, error handling) or provide usage context, leaving significant gaps for an AI agent to understand how to invoke it 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 67% (2 of 3 top-level parameters have descriptions), and the description adds no parameter semantics beyond the schema. It doesn't explain what 'deploymentConfig' entails or provide context for the parameters. With moderate schema coverage, the baseline is 3 as the description doesn't 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 action ('Updates') and resource ('a deployment of an Apps Script project'), making the purpose evident. It distinguishes from siblings like 'script_projects_deployments_create' (create) and 'script_projects_deployments_delete' (delete), though it doesn't explicitly differentiate from 'update_script_content' which updates content rather than deployments.

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. It doesn't mention prerequisites (e.g., existing deployment), exclusions, or compare to siblings like 'script_projects_deployments_create' for new deployments or 'update_script_content' for content updates, leaving usage context unclear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions OAuth authentication is handled automatically, which is useful context, but fails to describe critical behaviors like what metadata is returned, error conditions, rate limits, or whether this is a read-only operation. For a tool with 5 parameters and no annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get metadata of a Google Apps Script project') and adds one useful contextual note about authentication. There's no wasted verbiage or redundancy.

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

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

Given the complexity (5 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what 'metadata' includes, the response format, error handling, or how this differs from sibling tools. The authentication note is helpful but insufficient for a tool that likely returns 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 fully documents all 5 parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining the format of 'scriptId' or typical use cases for 'fields'. This meets the baseline of 3 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 verb ('Get') and resource ('metadata of a Google Apps Script project'), making the purpose immediately understandable. It doesn't explicitly differentiate from siblings like 'script_projects_get_content' or 'script_projects_versions_get', but the focus on 'metadata' provides some implicit distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention siblings like 'script_projects_get_content' (which retrieves content) or 'script_projects_versions_get' (which retrieves version details), leaving the agent to guess based on tool names alone.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states it 'gets' content, implying a read-only operation, but doesn't mention authentication requirements (though parameters suggest OAuth or API key), rate limits, error conditions, or what format the content returns (e.g., code files, JSON). For a tool with 7 parameters and no output schema, this is a significant gap in transparency.

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

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

The description is a single, clear sentence that efficiently conveys the core action without unnecessary words. It's front-loaded with the essential information ('Get the content'), making it easy to parse quickly, which is ideal for conciseness in tool definitions.

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 (7 parameters, no annotations, no output schema), the description is insufficiently complete. It doesn't explain what 'content' entails (e.g., source code, project structure), how authentication works despite parameters suggesting it, or return values, leaving the agent under-informed for effective use in a broader context 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?

Schema description coverage is 100%, with all parameters well-documented in the schema itself (e.g., scriptId, versionNumber, fields). The description adds no additional parameter semantics beyond implying retrieval of 'content,' which aligns with the schema but doesn't provide extra context like default behaviors or parameter interactions. 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 verb ('Get') and resource ('content of a Google Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'script_projects_get' (which might get metadata) or 'update_script_content' (which modifies content), leaving some ambiguity about its specific scope within the family of script project tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'script_projects_get' (likely for metadata) and 'update_script_content' (for modifications), there's no indication of the appropriate context or prerequisites for retrieving content specifically, leaving the agent to guess based on tool names alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a creation operation, implying mutation, but doesn't cover critical aspects like required permissions, whether this action is reversible, rate limits, or what happens to existing versions. For a mutation tool with zero annotation coverage, this is a significant gap in behavioral 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 a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, or behavioral nuances like side effects. With 2 parameters and 100% schema coverage, the parameter aspect is covered, but the overall context for safe and effective use is lacking.

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 100% description coverage, with both parameters ('scriptId' and 'description') clearly documented in the schema. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline of 3 for adequate but not additive parameter semantics.

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

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

The description clearly states the action ('Creates') and resource ('a new version of a Google Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'script_projects_create' or 'script_projects_deployments_create', which also create things in the script ecosystem.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing script project), when not to use it, or how it differs from similar creation tools in the sibling list, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but provides minimal information. It states this is a 'Get' operation which implies read-only behavior, but doesn't clarify authentication requirements (OAuth vs API key), rate limits, error conditions, or what specific version information is returned. For a tool with 10 parameters including authentication options, this lack of behavioral context is a significant gap.

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

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

The description is a single, clear sentence that states the core purpose without unnecessary words. It's front-loaded with the essential information and contains zero wasted language. For a tool with this level of schema documentation, the concise approach is appropriate and efficient.

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

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

Given the complexity (10 parameters including authentication options), lack of annotations, and absence of an output schema, the description is insufficiently complete. It doesn't address what information is returned about script versions, how authentication works, error handling, or how this differs from related tools. For a tool in a crowded namespace with authentication-sensitive operations, more contextual information is needed to guide proper usage.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema itself. The description doesn't add any parameter-specific information beyond what's already in the schema descriptions. It doesn't explain the relationship between required parameters (scriptId, versionNumber) and optional ones, or provide guidance on which authentication method to use. The baseline score of 3 reflects adequate but minimal value added beyond the comprehensive 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 ('Get') and resource ('a version of a Google Apps Script project'), making the purpose immediately understandable. It distinguishes this as a retrieval operation for specific versions rather than general project information or list operations. However, it doesn't explicitly differentiate from sibling tools like 'script_projects_get' or 'script_projects_versions_list', which would require more specific language about retrieving individual version details versus general project info or listing multiple versions.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools including 'script_projects_get', 'script_projects_versions_list', and 'script_projects_get_content', there's no indication whether this tool retrieves metadata, content, or other version-specific details. The agent must infer usage from the name alone, which is insufficient given the crowded tool namespace.

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 for behavioral disclosure. While 'List' implies a read-only operation, the description doesn't specify whether this requires authentication, has rate limits, returns paginated results (though schema hints at pagination via pageSize/pageToken), or what the output format looks like. For a tool with 9 parameters and no annotations, this leaves significant behavioral gaps.

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

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

The description is a single, clear sentence that states the core purpose without unnecessary words. It's front-loaded with the essential information ('List the versions'), making it efficient and easy to parse. Every word earns its place with zero redundancy.

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

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

Given the tool's complexity (9 parameters, no annotations, no output schema), the description is insufficient. It doesn't address authentication requirements, pagination behavior, error conditions, or relationship to sibling tools. For a list operation in a family of script project tools, more context about what 'versions' represent and how this fits into the broader workflow would be helpful.

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

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

Schema description coverage is 100%, so the schema fully documents all 9 parameters. The description adds no parameter-specific information beyond what's in the schema (e.g., it doesn't explain how scriptId is obtained or typical pageSize values). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't enhance parameter understanding but doesn't need to compensate 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 the verb ('List') and resource ('versions of a Google Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'script_projects_deployments_list' or 'script_projects_versions_get', which could cause confusion about when to use this specific list operation versus other list or get 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?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'script_projects_versions_get' (for a single version) and 'script_projects_deployments_list' (for deployments), the agent lacks context about when this list operation is appropriate versus other retrieval methods. No exclusions or prerequisites are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It states the action ('Run') but doesn't describe what happens during execution (e.g., synchronous/asynchronous, side effects, error handling, permissions required, or rate limits). For a tool that likely performs mutations, this lack of detail is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it immediately clear. Every word earns its place, and there's no redundancy or unnecessary elaboration.

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 running a script (likely a mutation with side effects), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns, error conditions, execution context, or how it differs from sibling tools. For a tool with 8 parameters and significant potential impact, more context is needed to guide safe and effective use.

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

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

The description adds no parameter semantics beyond what the input schema provides. However, schema description coverage is 100%, with all 8 parameters well-documented in the schema (e.g., scriptId, fields, alt, key). This meets the baseline of 3, as the schema does the heavy lifting, but the description doesn't enhance understanding of how parameters interact or affect execution.

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 ('Run') and resource ('a Google Apps Script'), making the purpose immediately understandable. It distinguishes this execution tool from sibling tools that focus on metrics, processes, projects, deployments, versions, or content updates. However, it doesn't specify what 'run' entails (e.g., execution of a function, deployment, or script trigger).

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. The description doesn't mention prerequisites (e.g., needing a script ID from another tool), appropriate contexts (e.g., testing vs. production), or comparisons to siblings like 'script_projects_deployments_create' or 'update_script_content'. Usage is implied but not explicitly defined.

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

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

No annotations are provided, so the description carries full burden. It states this is an update operation but doesn't disclose critical behavioral traits: whether this overwrites existing content, requires specific permissions, has rate limits, returns confirmation or error details, or affects running scripts. For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's appropriately sized and front-loaded, with every word contributing to understanding the core purpose.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't address what happens during the update (e.g., overwrite behavior, error handling), what permissions are needed, or what the return value looks like. With rich sibling tools and complex parameters (files array with nested objects), more context is needed for effective use.

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

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

Schema description coverage is 100%, with both parameters (scriptId, files) well-documented in the schema. The description adds no additional parameter semantics beyond implying content update, which is already clear from the tool name and schema. This meets the baseline of 3 when schema does the heavy lifting, but doesn't compensate with extra context like file format expectations or update constraints.

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

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

The description clearly states the action ('Updates') and resource ('content of a specified Google Apps Script project'), making the purpose immediately understandable. However, it doesn't differentiate this tool from similar siblings like 'script_projects_deployments_update' or 'script_projects_versions_create', which also involve updates to script-related entities.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools involving script updates (e.g., deployments_update, versions_create), there's no indication of whether this is for modifying source code versus other aspects, or any prerequisites like needing the script ID first from get_content tools.

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