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 correctly states this is a URL-building operation that doesn't make API calls, which is useful context. However, it lacks information about error handling, performance characteristics, authentication requirements, or what happens with invalid parameters. For a tool with complex nested parameters, more behavioral context would be helpful.

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

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

The description is perfectly concise with two sentences that each earn their place. The first sentence states the core purpose, and the second provides crucial behavioral context about not making API calls. No wasted words or redundant information.

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

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

Given the tool's moderate complexity (4 parameters with nested objects) and excellent schema coverage (100%), the description is adequate but minimal. It lacks output information (no output schema provided), doesn't explain what the built URL is used for, and provides limited behavioral context. For a pure computation tool, this might be sufficient, but more context about typical use cases would improve completeness.

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

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

The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond what's in the schema - it mentions 'transform parameters' which aligns with the 'transforms' object but doesn't provide additional semantic context. With excellent schema documentation, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Build a Spronta CDN URL with transform parameters.' It specifies the action (build), resource (CDN URL), and scope (transform parameters). However, it doesn't explicitly differentiate from sibling tools like 'generate_signed_url' or 'upload_image' that might also involve URL generation or image handling.

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

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

The description provides some implied usage context by stating 'Does not make an API call,' which suggests this is a local computation tool rather than a network operation. However, it doesn't explicitly guide when to use this vs. alternatives like 'generate_signed_url' (which might create authenticated URLs) or 'upload_image' (which involves actual file transfer). No explicit when-not-to-use or prerequisite information is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool creates a preset for use in CDN URLs, but lacks details on permissions required, whether the operation is idempotent, error handling, or rate limits. For a creation tool with no annotations, 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 extremely concise with two sentences that are front-loaded and waste no words. The first sentence states the purpose, and the second provides usage context, making it 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 (3 parameters with nested objects) and lack of annotations or output schema, the description is minimally adequate. It covers the purpose and basic usage but does not address behavioral aspects like side effects, response format, or error conditions, which are important for a creation tool.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description does not add any additional semantic details about the parameters beyond what the schema provides, such as explaining the relationship between 'transforms' and the preset's functionality. 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 action ('Create a named transform preset') and the resource ('preset'), distinguishing it from siblings like 'update_preset' or 'delete_preset'. It also specifies the practical use case ('Use in CDN URLs with ?t=preset-name'), making the purpose specific and actionable.

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 on when to use the tool ('Use in CDN URLs with ?t=preset-name'), which helps differentiate it from tools like 'build_cdn_url' or 'update_preset'. However, it does not explicitly state when not to use it or mention alternatives, such as using direct transform parameters instead of a preset.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a creation tool, implying a write operation, but doesn't cover critical aspects like permissions required, whether it's idempotent, error handling, or what happens on success (e.g., returns a project ID). 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 with zero waste—it directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple creation tool and front-loaded with the essential action and resource.

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 as a mutation operation with no annotations and no output schema, the description is incomplete. It doesn't explain what an 'image project' is, what happens after creation (e.g., returns a project object or ID), or any behavioral traits like side effects. For a tool that likely alters system state, more context is needed to guide 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 the single parameter 'name' fully documented in the schema (type, description, length constraints). The description adds no additional parameter semantics beyond implying the name is for a project. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't enhance parameter understanding.

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

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

The description clearly states the action ('Create') and resource ('new image project'), making the purpose immediately understandable. It distinguishes from siblings like 'update_project' or 'delete_project' by specifying creation rather than modification or deletion. However, it doesn't specify what an 'image project' entails beyond the name, leaving some ambiguity about the resource's nature.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., authentication needs), when not to use it (e.g., if a project already exists), or direct alternatives among siblings (e.g., 'update_project' for modifications). The agent must infer usage from context 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. It discloses critical behavioral traits: the operation is permanent and irreversible ('Cannot be undone'), which is essential for a destructive action. However, it lacks details on permissions, error handling, or side effects.

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

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

The description is two sentences with zero waste: the first states the action and scope, the second warns of irreversibility. It is front-loaded and 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?

Given the destructive nature, no annotations, and no output schema, the description is reasonably complete—it covers the irreversible action. However, it could improve by mentioning permissions or response format, but it's adequate for a simple delete operation.

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 the parameters. The description does not add any additional meaning beyond what the schema provides (e.g., no extra context on parameter usage or constraints), meeting the baseline for high 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 action ('permanently delete') and the resource ('an image from storage and database'), distinguishing it from siblings like 'update_image' or 'list_images'. It's specific about the irreversible nature of the operation.

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

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

The description implies usage for deletion of images, but does not explicitly state when to use this tool versus alternatives (e.g., 'update_image' for modifications or 'list_images' for viewing). No guidance on prerequisites or exclusions is provided.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive operation, the description doesn't specify whether deletion is permanent, reversible, requires specific permissions, or has side effects. It also doesn't mention what happens if the preset is in use or what the response looks like.

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

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

The description is extremely concise with just four words, front-loading the essential information with zero wasted language. Every word earns its place in 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?

For a destructive operation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address critical contextual information like confirmation requirements, error conditions, or what happens after deletion. The minimal description leaves too many behavioral 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 already documents both parameters thoroughly. The description doesn't add any additional meaning about the parameters beyond what's in the schema, maintaining the baseline score 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 action ('Delete') and target resource ('a transform preset'), providing specific verb+resource pairing. However, it doesn't differentiate from sibling tools like 'delete_image' or 'delete_project' which perform similar deletion operations on 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. There's no mention of prerequisites, consequences, or comparison to related tools like 'update_preset' or 'create_preset' that might be alternatives for managing presets.

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 key behavioral traits: the permanence of deletion ('Permanently delete,' 'cannot be undone') and the scope of destruction ('all its images'). However, it doesn't mention permissions, rate limits, or error conditions, leaving some 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?

Two sentences with zero waste: the first states the action and scope, the second warns about irreversibility. It's front-loaded with the core purpose and appropriately sized for a destructive operation.

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 reasonably complete—it clearly communicates the irreversible nature and scope. However, it could benefit from mentioning typical use cases or prerequisites, given the high stakes of deletion.

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 projectId parameter and its optional nature with environment variable fallback. The description doesn't add any parameter-specific details beyond what the schema provides, meeting the baseline for high 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 delete') and resource ('a project and all its images'), distinguishing it from siblings like delete_image (which deletes individual images) and delete_preset (which deletes presets). It provides explicit scope information about what gets deleted.

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

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

The description implies usage context through 'This cannot be undone,' suggesting irreversible consequences, but doesn't explicitly state when to use this tool versus alternatives like update_project or when deletion is appropriate. No prerequisites or comparisons to sibling tools are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the prerequisite 'Requires signing to be enabled,' which is useful context about authentication/configuration needs. However, it lacks details on rate limits, error conditions, what happens if signing isn't enabled, or the format of the generated URL. For a tool that generates signed URLs (a security-sensitive operation), 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 extremely concise—two short sentences with zero wasted words. The first sentence states the core purpose, and the second adds critical prerequisite information. It is appropriately sized and front-loaded, with every sentence 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 the complexity (generating signed URLs with cryptographic operations), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a URL string, error formats), security implications, or detailed behavioral traits. The prerequisite hint is helpful but insufficient for full contextual understanding.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters (projectId, path, params, expiresIn). The description adds no parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the tool's purpose: 'Generate an HMAC-SHA256 signed CDN URL.' It specifies the cryptographic method (HMAC-SHA256) and resource type (CDN URL), which distinguishes it from sibling tools like 'build_cdn_url' (likely unsigned) and 'upload_image'. However, it doesn't explicitly differentiate from 'update_signing' or 'get_signing_config', which are related to signing configuration.

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 some usage context: 'Requires signing to be enabled.' This implies a prerequisite but doesn't explicitly state when to use this tool versus alternatives like 'build_cdn_url' (for unsigned URLs) or 'update_signing' (to enable signing). No explicit when-not-to-use guidance or alternative tool recommendations are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), but doesn't cover aspects like authentication requirements, error handling, rate limits, or what happens if the project ID is invalid. For a 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 could be slightly improved by front-loading more critical information, but it's appropriately sized and wastes no space.

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

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

Given the tool's low complexity (one optional parameter) and high schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it lacks details on behavioral traits and return values, leaving gaps for an AI agent to infer.

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 'projectId' with its type and optional behavior. The description doesn't add any parameter-specific information beyond what's in the schema, such as format details or examples, but 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 tool's purpose with a specific verb ('Get') and resource ('project details'), including what information is retrieved ('usage stats (image count, total storage)'). However, it doesn't explicitly differentiate from sibling tools like 'list_projects' or 'get_usage', which reduces it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_projects' (for listing multiple projects) or 'get_usage' (which might overlap with usage stats), nor does it specify prerequisites or contexts for use.

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

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

No annotations are provided, so the description carries full burden. It mentions what data is returned (enabled, requireSignedUrls, masked secret), which adds some behavioral context. However, it lacks details on permissions needed, error conditions, rate limits, or whether it's a read-only operation (implied by 'Get' but not explicit).

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

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

The description is a single, efficient sentence that front-loads the core purpose and lists key return values. There's no wasted language, and 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?

Given no annotations, no output schema, and a simple input schema, the description is minimally adequate. It specifies what data is retrieved, but lacks details on return format, error handling, or operational context. For a read operation with one optional parameter, it's passable but could be more informative.

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 'projectId' fully documented in the schema (type, optionality, env var fallback). The description adds no additional parameter semantics beyond what the schema provides, so it meets 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 action ('Get') and the resource ('URL signing configuration for a project'), specifying what information is retrieved (enabled status, requireSignedUrls, masked secret). It distinguishes from siblings like 'update_signing' (which modifies) and 'get_project' (which retrieves general project info), but doesn't explicitly contrast with all siblings.

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

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

No guidance is provided on when to use this tool versus alternatives. While it's implied this retrieves signing configuration specifically, there's no mention of prerequisites, when it's appropriate versus other tools like 'get_project' for general info, or any contextual constraints.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves metrics, implying a read-only operation, but doesn't disclose any behavioral traits such as rate limits, authentication requirements, or what happens if the project ID is invalid. The description is minimal and lacks context beyond the basic action, leaving gaps in understanding how the tool behaves in practice.

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: 'Get daily usage metrics (requests, bandwidth, transforms) for a project.' It is front-loaded with the core purpose, uses parentheses to list metric types concisely, and has zero wasted words. Every part of the sentence earns its place by clarifying the tool's function without redundancy.

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

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

Given the tool's moderate complexity (2 parameters, no output schema, no annotations), the description is minimally adequate but has clear gaps. It explains what the tool does but lacks usage guidelines, behavioral details, and output information. Without annotations or an output schema, the description should do more to cover aspects like return format or error handling, but it only provides a basic overview, making it incomplete for full contextual understanding.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('projectId' and 'days'), including defaults and constraints. The description adds no additional parameter semantics beyond what the schema provides, such as explaining the meaning of 'transforms' or how metrics are aggregated. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, but the description doesn't compensate with extra insights.

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

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

The description clearly states the tool's purpose: 'Get daily usage metrics (requests, bandwidth, transforms) for a project.' It specifies the verb ('Get'), resource ('daily usage metrics'), and scope ('for a project'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_project' or 'list_projects', which might also retrieve project-related data but for different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, exclusions, or specific contexts for usage. For example, it doesn't clarify if this is for monitoring vs. administrative purposes or how it differs from sibling tools like 'get_project' that might provide project details without usage metrics.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination, which is useful, but doesn't cover critical aspects like whether this is a read-only operation, authentication requirements, rate limits, error conditions, or what the output format looks like.

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 wasted words. It's appropriately sized and front-loaded with the core purpose, making it easy to parse quickly.

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

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

For a list operation with no annotations and no output schema, the description is incomplete. It doesn't explain what information is returned about each image, how pagination works beyond mentioning it, or any behavioral constraints. This leaves significant gaps for an agent trying to use the tool effectively.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline expectation but not providing 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 ('images in a project'), making the purpose understandable. However, it doesn't distinguish this tool from other list operations like 'list_presets' or 'list_projects', which would require more specificity to earn a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions pagination, but doesn't clarify scenarios where this tool is preferred over other list operations or how it relates to tools like 'get_project' or 'upload_image'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists presets and mentions their use in CDN URLs, but it does not cover critical behaviors like whether this is a read-only operation, if it requires authentication, any rate limits, or what the output format looks like (e.g., list structure, pagination). For a tool with no annotations, 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 very concise, consisting of two short sentences that directly state the purpose and a key use case. It is front-loaded with the main action and avoids any unnecessary details, making it efficient and easy to parse for an AI agent.

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

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

Given no annotations and no output schema, the description is incomplete for a tool that likely returns a list of presets. It lacks details on behavioral traits (e.g., safety, authentication), output format, or error handling. While the purpose is clear, the overall context is insufficient for an agent to fully understand how to invoke and interpret results from this tool.

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

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

The input schema has 100% description coverage, with the parameter 'projectId' fully documented in the schema itself. The description does not add any additional meaning or context about the parameter beyond what the schema provides, such as explaining why projectId might be omitted or how it relates to presets. Baseline score of 3 is appropriate as the schema handles the parameter documentation adequately.

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 the resource 'named transform presets', specifying what the tool does. It also mentions that presets can be used in CDN URLs, which adds useful context. However, it does not explicitly differentiate from sibling tools like 'get_project' or 'list_projects', which might list other resources, keeping it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'list_images' or 'list_projects', or any prerequisites for usage. It mentions presets can be used in CDN URLs, but this is more of a feature explanation than usage guidance, leaving the agent with no explicit when-to-use instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists projects but doesn't mention any behavioral traits such as pagination, rate limits, or authentication requirements, leaving 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 directly states the tool's function without unnecessary words. It is front-loaded and wastes no space, making it highly concise.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the return values are (e.g., project details, format) or address potential complexities like filtering or sorting, which are important for a listing tool.

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

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

The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The baseline for this scenario is 4, as the description appropriately avoids redundant information.

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 ('Spronta image projects'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_images' or 'list_presets', which prevents a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_project' or 'list_images'. The description implies a general listing function but offers no context on usage scenarios or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation but doesn't mention required permissions, whether changes are reversible, rate limits, error conditions, or what happens when only some fields are provided. For a mutation 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 with zero wasted words. It's front-loaded with the core action and immediately specifies what can be updated. Every word earns its place in conveying the essential 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?

For a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the tool returns, error conditions, side effects, or authentication requirements. The agent must rely entirely on the input schema and trial-and-error for behavioral 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%, so the schema already documents all 4 parameters thoroughly. The description adds minimal value beyond what's in the schema - it mentions 'alt text and/or tags' which aligns with two parameters but doesn't provide additional context about projectId fallback behavior or tag/altText constraints beyond schema descriptions.

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

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

The description clearly states the action ('Update') and target resource ('an image's alt text and/or tags'), making the purpose immediately understandable. It distinguishes from siblings like delete_image or upload_image by focusing on metadata modification rather than creation/deletion. However, it doesn't explicitly differentiate from update_preset or update_project which also modify 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. It doesn't mention prerequisites (like needing an existing image), when not to use it (e.g., for bulk updates), or how it differs from similar tools like update_project. The agent must infer usage from the tool name and parameter 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 the full burden of behavioral disclosure but provides minimal information. It states this is an update operation but doesn't mention permission requirements, whether the update is destructive to existing data, error conditions, or what happens when only partial fields are provided. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is extremely concise - a single sentence that gets straight to the point with no wasted words. It's front-loaded with the essential information and doesn't include any unnecessary elaboration or repetition.

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 is inadequate. It doesn't explain what the tool returns, what happens on success/failure, or important behavioral aspects like whether the update is partial or requires all fields. Given the complexity of the transforms object with many nested properties, more context would be helpful.

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

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

The description mentions 'name or transforms' which maps to two of the four parameters, but with 100% schema description coverage, the schema already fully documents all parameters including projectId, presetId, name, and transforms with all their nested properties. The description adds minimal value beyond what's already in the well-documented 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 ('Update') and the resource ('a preset's name or transforms'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'update_image' or 'update_project' - it only tells what it does, not how it differs from similar update 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. There's no mention of prerequisites (like needing a preset to exist first), no comparison to sibling tools like 'create_preset' or 'update_image', and no context about when this operation is appropriate versus creating a new preset.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool updates a project, implying a mutation, but doesn't cover critical aspects like required permissions, whether changes are reversible, error handling (e.g., invalid domain), or response format. 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 core action and resource, making it easy to parse. Every part of the sentence contributes essential information.

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

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

Given the tool's complexity (mutation with 3 parameters) and lack of annotations and output schema, the description is incomplete. It doesn't address behavioral traits like side effects, authentication needs, or return values, leaving significant gaps for an AI agent to understand how to invoke it correctly and interpret results.

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 three parameters well-documented in the schema (e.g., projectId uses env var fallback, name has length constraints, customDomain allows null for removal). The description adds minimal value beyond the schema by listing updatable fields ('name or custom domain'), but doesn't provide additional context like formatting rules or interactions between parameters.

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

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

The description clearly states the action ('Update') and the resource ('project'), specifying what can be updated ('name or custom domain'). It distinguishes from siblings like 'create_project' or 'delete_project' by focusing on modification rather than creation or deletion. However, it doesn't explicitly differentiate from 'update_preset' or 'update_signing', which target 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. It doesn't mention prerequisites (e.g., needing an existing project), exclusions (e.g., what cannot be updated), or comparisons to siblings like 'get_project' for viewing or 'create_project' for initial setup. Usage is implied only by the verb 'Update'.

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 disclosing key behavioral traits: it explains the effect of enabling (generates a new secret, returned once) and disabling, which goes beyond the input schema. However, it does not cover aspects like permissions needed, rate limits, or error conditions, leaving some 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 front-loaded and highly concise with just one sentence that efficiently conveys the tool's purpose and key behavior. Every word earns its place, with no redundant or vague language.

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

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

Given the tool's moderate complexity (a mutation tool with 3 parameters), no annotations, and no output schema, the description is somewhat complete but has gaps. It covers the core action and secret generation, but lacks details on permissions, error handling, or what 'returned once' entails, which could hinder an agent's 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%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by implying the 'enabled' parameter's effect on secret generation, but does not provide additional syntax, format, or interaction details 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 a specific verb ('Enable/disable') and resource ('URL signing'), and distinguishes it from siblings like 'generate_signed_url' (which generates URLs) and 'get_signing_config' (which reads config). It also mentions the key behavioral detail about secret generation when enabling.

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 it (to enable/disable URL signing) and implies usage relative to siblings by mentioning secret generation, but does not explicitly state when to use alternatives like 'get_signing_config' for reading or 'generate_signed_url' for URL creation. It lacks explicit exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool fetches from a URL, uploads to Spronta, and returns a CDN URL with blurhash, which covers core behavior. However, it omits details like error handling, rate limits, authentication needs, or whether the operation is idempotent, leaving 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 two sentences, front-loaded with the main purpose and outcome, followed by a concise note on the base64 alternative. Every sentence adds necessary information without waste, making it efficient and easy to parse.

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

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

Given no annotations and no output schema, the description covers the basic operation and parameter alternatives adequately. However, as a mutation tool with 5 parameters, it lacks details on return values (beyond mentioning CDN URL with blurhash), error cases, or side effects, leaving room for improvement in completeness.

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

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

Schema description coverage is 100%, so the schema already documents all parameters well. The description adds value by clarifying the alternative between 'imageUrl' and 'imageData' (base64), which isn't explicit in the schema, and hints at the auto-detection for 'contentType'. This compensates slightly beyond 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 uploads an image from a URL or base64 data to Spronta and returns a CDN URL with blurhash. It specifies the action (upload), resource (image), and outcome, but doesn't explicitly differentiate from sibling tools like 'update_image' or 'delete_image' beyond the upload focus.

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

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

The description implies usage by mentioning alternatives (URL vs. base64) and notes that 'projectId' can be omitted to use an environment variable. However, it lacks explicit guidance on when to use this tool versus siblings like 'generate_signed_url' or 'update_image', or any prerequisites or exclusions.

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