Uwear

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

Annotations already provide destructiveHint=true and readOnlyHint=false. The description adds that the operation is reversible via update_production_workflow, a non-obvious behavioral detail beyond the schema. It clarifies the specific state change (archive+disable), adding context beyond the safety flags.

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

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

A single sentence that is front-loaded with the action and includes the crucial reversibility note. No filler.

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

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

Given the tool's simplicity (one parameter, clear annotations, output schema present), the description covers the essential behavior and reversal path. The lack of detailed edge cases is acceptable for this level of complexity.

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

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

The input schema has 100% coverage for the single workflow_id parameter, documenting it as a UUID. The description does not add additional parameter constraints or context, so it meets the baseline for schema-driven clarity.

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

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

The description states a specific action ('Archive a workflow and disable it') with a clear resource (workflow). It also references the reversal tool, distinguishing it from other workflow-related tools. This gives strong purpose clarity.

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

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

The description succinctly conveys when to use the tool (to archive/disable a workflow) and points to update_production_workflow for reversal, showing awareness of an alternative. It does not explicitly enumerate exclusions, but the context is sufficiently clear.

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

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

Beyond the sparse annotations, the description discloses that the operation is asynchronous, returns a job ID, and requires polling until status is done or failed. It also explains the save flag's behavioral impact. It does not cover edge cases like failure handling or permissions, but the workflow is well communicated.

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

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

The description is three sentences, front-loaded with the core action ('Queue the conversation for asynchronous ArtDirection authoring'), followed by parameter guidance and polling instruction. Every sentence serves a purpose with no redundancy.

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

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

The description tells the agent what to expect (job ID) and what to do next (poll get_art_direction_authoring_job). It is complete for an async tool with 5 parameters and no output schema, though it could benefit from an explicit contrast with the synchronous create_art_direction sibling.

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

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

Schema coverage is 100%, so the baseline is 3. The description reiterates the save=true/false semantics already present in the schema, but adds no new meaning for other parameters. It does not compensate beyond the schema's existing clarity.

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 queues the conversation for asynchronous ArtDirection authoring using Uwear's prompt system. It distinguishes itself from siblings by emphasizing the asynchronous job model and the need to poll for completion. The save=true/false distinction further clarifies its purpose.

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

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

The description provides explicit guidance on when to use save=true vs save=false and instructs to call get_art_direction_authoring_job until done or failed. However, it does not explicitly name an alternative tool (e.g., create_art_direction) or state when not to use this tool, so it misses a 5.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, establishing this as a safe, read-only, idempotent operation. The description adds the context that it should be skipped when the input prompt is already specific, which is useful but not a major behavioral disclosure. Since annotations cover the safety profile, this is adequate.

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 exactly two sentences, front-loaded with the purpose and followed by usage guidance. No redundant phrasing.

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

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

For a simple, side-effect-free tool with no required parameters and full schema coverage, the description covers the core purpose and the key decision of when to skip it. It doesn't explicitly state the return format, but the tool name and description imply a prompt string, and annotations cover safety. Complete enough.

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?

All 5 parameters are fully described in the schema (100% coverage), so the description doesn't need to repeat them. The description's mention of 'user's rough description' aligns with the user_text parameter, but the schema already documents each parameter thoroughly. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: building a highly detailed prompt for avatar/model generation. It distinguishes itself from the sibling generate_avatar by explicitly saying that if the user's prompt is already intentional, the system can skip this and pass wording directly to generate_avatar, making sibling differentiation clear.

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

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

The description gives explicit conditions for when to use this tool ('when the user wants help describing a person before image generation') and when to skip it in favor of an alternative ('if the user's prompt is already intentional and specific... pass directly to generate_avatar'). This directly addresses usage vs alternatives.

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

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

The description adds valuable behavioral context beyond annotations: it explains the idempotent execution behavior ('Repeated calls return or resume the same durable execution'), defines the default execute=true semantic in MCP context, and instructs to use the visible/latest brief_id. This complements the idempotentHint and destructiveHint annotations without contradicting them.

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

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

Three sentences, each earning its place. The purpose is front-loaded, the idempotency and parameter semantics are efficiently explained, and the description is free of fluff 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?

Given the tool's moderate complexity, the description covers all essential aspects: what it does, idempotent behavior, the brief_id source, and the execute semantics. With no output schema, it still gives a sense of return behavior ('same durable execution'). It could mention potential errors, but the current coverage is sufficient for an agent to use 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?

The schema already documents both parameters with 100% coverage, but the description enriches semantics by specifying that brief_id should be the 'visible/latest BriefProposal brief_id' and clarifies the execute parameter's default behavior and the exception for setting it false. This adds value beyond the raw schema.

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

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

The description clearly states the tool's function: approve and idempotently execute a visible persisted Uwear brief. It uses a specific verb ('approve and execute') and resource ('persisted Uwear brief'), and the emphasis on 'idempotently' distinguishes it from ordinary confirmation 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?

Provides explicit guidance on when to call (upon user confirmation phrases like 'looks good' or 'run it') and when not to (if the user explicitly wants approval without execution, set execute=false). However, it does not name alternative sibling tools, but it does clarify the MCP meaning of 'confirm'.

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?

Annotations are all false, so no protective or destructive hints are present. The description adds the key nuance that this is a direct writer for already-structured markdown, but it does not disclose other behaviors such as validation, overwrite semantics, or return values. The parser contract is also repeated in the schema, so the marginal description value is moderate.

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

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

The description is two sentences: the first states the purpose and the second gives usage guidance. It is front-loaded, scannable, and contains no filler, making it an exemplar of concise yet informative writing.

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 output schema and moderate complexity, the description covers the essential decision of when to use it and what input it expects. It could mention the result of the creation (e.g., saved entity) or any side effects, but the sibling tools and schema fill most gaps. A score of 4 reflects solid but not exhaustive 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% with detailed explanations for all three parameters. The description does not add extra parameter semantics beyond referencing the parser contract in content_markdown, so the baseline of 3 is appropriate.

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

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

The description begins with 'Create a company ArtDirection markdown document,' using a specific verb and resource. It immediately distinguishes the tool from its sibling author_art_direction by noting when to prefer that alternative. This makes the purpose clear and uniquely positioned among the 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 explicitly states to use author_art_direction first for rough creative text or reference images, and to use this direct writer only for already-structured markdown that follows the Variation Controls parser contract. This provides clear when-to-use guidance and names the alternative.

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?

Annotations indicate a mutating operation (readOnlyHint=false), and the description adds important behavioral context beyond that: 'The tool only creates a payment link; the user must open and complete payment in Stripe.' This clarifies that the tool does not finalize the purchase. However, it does not mention potential side effects like whether credits are reserved or any authorization requirements.

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

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

The description is four sentences, each earning its place: purpose, usage, exclusion, and behavioral limitation. It is front-loaded with the core function and contains no redundant filler.

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

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

The tool has no output schema, but the description implies the return is a Stripe Checkout URL and indicates user action is needed. This is sufficient for basic invocation. It lacks detail on the response format or any post-payment flow, but given the moderate complexity and strong annotations, completeness is adequate.

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

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

Schema description coverage is 100% with every parameter documented. The description adds overall context but does not elaborate on parameter-specific semantics beyond the schema. Baseline 3 is appropriate since the schema carries the full parameter meaning.

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

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

The description opens with a specific verb and resource: 'Create a hosted Stripe Checkout URL for buying Uwear generation credits.' This clearly distinguishes the tool from siblings like get_user_credits and estimate_cost. The scope is unambiguous.

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

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

Explicit usage criteria are provided: 'Use only when the user explicitly asks to buy, add, top up, or purchase credits, or when they ask how to continue after insufficient credits.' It also states a clear exclusion: 'Do not call during photoshoot planning unless the user requested checkout.' This gives the agent strong decision guidance.

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

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

With annotations only providing false hints for readOnly, openWorld, idempotent, and destructive, the description adds meaningful behavior: the backend analyzes the image if description is omitted, and the tool returns a location_id for reuse. This goes beyond the schema and annotations, though it doesn't disclose potential side effects or validation rules.

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 core purpose, and every clause earns its place. It efficiently conveys creation, the optional-description behavior, and the output usage without extraneous words.

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

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

For a create tool with 6 parameters and no output schema, the description covers the core workflow (image URL -> location reference), the optional-description behavior, and the required output hint (location_id). It stops short of describing full response structure or error cases, but the essential context for an agent to invoke it correctly is present.

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

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

The input schema already provides descriptions for all 6 parameters, including the optional description field and its image-analysis fallback. The tool description repeats this internal behavior but does not add new parameter-level meaning. Since schema coverage is 100%, the score is at baseline 3, with no significant value added by 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 uses a specific verb-resource pair ('Create a reusable location/scene reference') and clearly differentiates from sibling tools like get_location and list_locations by focusing on creation. It also states the intended downstream use in propose_brief/update_brief, which solidifies its unique role.

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

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

The description explicitly instructs to use the returned location_id in propose_brief/update_brief, giving clear context for when this tool is appropriate. It does not list exclusions or alternatives, but the workflow reference implies the use case sufficiently.

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?

Annotations already communicate that the tool is mutating (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds minimal context by clarifying that it pairs existing garments without uploading new images, but it does not disclose additional side effects, permissions, or return behavior beyond what is implied.

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

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

The description consists of two concise sentences, with the primary purpose front-loaded and no redundant or extraneous information. Every word earns its place.

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

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

For a simple create operation with full schema coverage and clear annotations, the description adequately explains the tool's functionality. The lack of an output schema is not a major gap given the straightforward nature of the 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% for all three parameters, so the description does not need to add parameter-level details. The description implicitly references the purpose of clothing_item_ids but adds no new semantics beyond the schema.

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

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

The description clearly states the action (create), the resource (outfit), and the source (existing garment IDs). It also distinguishes from upload-related tools by noting that no new images are uploaded, making the purpose unambiguous.

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

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

The description implies usage when garment IDs already exist and an outfit needs to be composed, but it does not explicitly state when not to use the tool or mention alternatives like propose_outfits or upload_garment_from_chat_file. No exclusions 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?

Annotations provide no hints (all false), so the description carries the behavioral burden. It transparently discloses that the created workflow is inert until version creation and publication, which is vital side-effect information. No contradiction with annotations.

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

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

Two concise sentences, front-loaded with the action. Every phrase earns its place: it states the function and the two life-cycle limitations that matter for usage.

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 simple parameter set (one nested object), the output schema, and the presence of closely related sibling tools, the description fully explains the tool's role in the workflow lifecycle. No significant missing information.

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

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

Schema coverage is 100%, but the description adds meaning by explaining the lifecycle constraint behind the 'enabled' parameter: 'runs nothing until a version is published.' This complements the schema's note that enabled must be false until publication, providing rationale beyond field definitions.

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

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

The description clearly states the tool's function: 'Create a workflow.' It also clarifies the initial state (no graph, not running), distinguishing it from creating a workflow version or publishing. This is specific and differentiates from siblings like create_production_workflow_version.

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: creation is just the first step, and a version must be created and published before it runs. This implicitly tells the agent that create_production_workflow_version and publish_production_workflow_version are next steps. Clear context but no explicit alternative exclusion.

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

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

The description discloses two key behavioral traits: drafts are editable and never execute. However, annotations are all false and thus provide no positive safety profile; the description does not cover return value, failure modes, or side effects such as whether calling this multiple times creates multiple drafts. More behavioral context would be needed for full 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 three short sentences that front-load the purpose, then add behavioral context and a documentation reference. Every sentence earns its place; there is no redundancy or filler.

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

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

Given the tool's complexity (deeply nested schema, no output schema, all-false annotations), the description is partially complete: it states the action, key behavior, and points to docs. However, it does not mention the return value, prerequisites (e.g., workflow exists), or possible errors, which are important for a create 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 provides basic descriptions (e.g., 'Draft workflow graph...'). The description adds extra value by pointing to 'uwear://contracts/production-workflow for typed node configs and worked examples', which is especially helpful for the complex definition parameter.

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

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

The description uses a specific verb+resource, 'Open a new draft version holding the graph', and clearly distinguishes from siblings like publish_production_workflow_version and create_production_workflow. The phrase 'Drafts are editable and never execute' further clarifies the tool's role in the workflow lifecycle.

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

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

The description implies when to use this tool (whenever you need a new draft version) and clarifies that drafts never execute, but it does not explicitly name alternatives or exclusion criteria. It lacks a 'when to use this vs. update/publish' guidance, so usage context is only partially conveyed.

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?

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds the workspace requirement but doesn't disclose uniqueness enforcement or idempotency-related behavior (e.g., what happens if a duplicate name is submitted). No contradiction with annotations.

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

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

The description is a single front-loaded sentence that communicates the core functionality. The asset type list is slightly detailed but remains compact and useful.

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

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

For a simple create tool with full schema coverage and no output schema, the description and schema together provide sufficient guidance. It could mention return values or duplicate-name behavior, but these are not critical for tool selection and invocation.

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

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

Schema description coverage is 100%, with both parameters fully described (name with uniqueness and maxLength; color with format example). The description adds no parameter-specific meaning beyond listing asset types, so baseline 3 is appropriate.

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

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

The description clearly states the action ('Create a new tag'), the resource ('for organizing assets'), and enumerates the asset types. This distinguishes it from sibling tools like list_tags and get_items_by_tag, which have different purposes.

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

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

The description provides a clear precondition ('Requires an active company workspace') and indicates a broad use case (organizing assets). It doesn't explicitly name alternatives or when-not-to-use scenarios, but the context is sufficient for a simple create tool.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds the behavioral trait of permanence ("Permanently delete") and an ownership constraint, which are not explicitly stated in annotations. This goes beyond the minimal annotation information.

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 concise sentences, clearly front-loaded with the action and resource. No redundant phrasing or filler. Every word adds value.

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

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

For a simple delete tool with one parameter and no output schema, the description covers the essential context: permanent deletion and a key caveat about owner-only templates. It could mention error conditions or permissions, but given the tool's simplicity, it is sufficiently complete.

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

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

The schema covers 100% of parameters with a single template_id and its description. The tool description does not add significant semantic detail beyond the schema, and the schema already describes the template as a 'company template.' The parameter is straightforward, so the baseline of 3 applies.

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 a library template." This uses a specific verb (delete) and resource (library template), which directly distinguishes it from sibling tools like get_template, save_template, and list_templates.

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

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

The description includes an important usage exclusion: "Owner-only templates must be deleted through their owning resource." This provides guidance on when NOT to use this tool, implying an alternative exists. It could be improved by explicitly stating the general use case (delete any library template) but the purpose makes it evident.

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

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

The description discloses that the URL is time-limited, which is a behavioral trait not present in the annotations. It also implies the bundling action without claiming any destructive effect; this aligns with destructiveHint=false. However, it does not detail side effects (e.g., storage retention) beyond the essentials.

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, front-loaded with the tool's core function and closes with a clear usage directive. No redundant verbiage, making it appropriately 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?

For a tool with only two parameters and no output schema, the description sufficiently covers what it does, what it returns (download URL), and a caveat (time-limited). It is complete for the complexity level, and the clear usage line covers the standalone context.

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

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

Schema description coverage is 100% with both parameters well-documented (export_format with examples, generation_result_ids with min/max). The description does not add parameter-level meaning beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description starts with a specific action ('Bundle generation results into a ZIP') and specifies the outcome ('return a time-limited download URL'). This clearly distinguishes it from sibling tools like get_generation_results, which retrieves results but does not package them for download.

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

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

It provides an explicit usage trigger: 'Use when the user wants to download or export their generated images/videos.' This is clear context but does not mention when not to use it or alternatives, so it stops short of a 5.

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?

Annotations indicate a non-read-only, non-destructive mutation (readOnlyHint=false, destructiveHint=false). The description adds context that the copy is 'editable' and that the source can be system or company, but it does not disclose details like whether the original remains unchanged, permissions required, or potential side effects. With annotations providing baseline safety info, this is adequate but not rich.

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

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

A single sentence that is direct and complete. It conveys the core purpose without extraneous detail, making it easy to parse and understand.

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

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

With no output schema, the description should at least hint at the return value, but it only says the result is an 'editable company copy' without specifying what is returned (e.g., the new copy's ID). It also omits whether the original is preserved, though that is implied by 'duplicate.' For a simple tool, this is minimally sufficient but leaves some gaps.

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

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

Schema covers both parameters (art_direction_id and name) with descriptions, achieving 100% coverage. The description does not add any additional meaning about parameter usage beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (duplicate), the resource (system or company ArtDirection), and the outcome (an editable company copy). This distinguishes it from sibling tools like create_art_direction or update_art_direction by focusing on the duplication aspect.

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

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

The description implies when to use this tool (when you want an editable company copy of an existing ArtDirection) but does not explicitly mention alternatives or exclude other tools. It lacks direct guidance such as 'use instead of create_art_direction when you want a copy based on an existing system or company ArtDirection.'

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?

Annotations already mark the tool as read-only, idempotent, and non-destructive, so the agent knows it is a safe calculation. The description adds no behavioral context beyond the name, such as whether the estimate is approximate or depends on current pricing. It does not contradict the annotations.

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

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

The description is a single, focused sentence with no extraneous words. It is front-loaded with the verb and object. While it is brief, this is not a flaw; it earns its place.

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

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

Despite having six parameters and no output schema, the description does not clarify what the tool returns (e.g., a numeric credit amount, a breakdown) or how the estimate is computed. The annotations cover safety but not functional expectations. This leaves the agent guessing about the tool's 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?

The input schema provides 100% coverage of all six parameters with descriptive details (e.g., operation enum values, duration constraints, generate_audio doubling cost). The description adds no additional parameter semantics, so the baseline score of 3 applies.

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 function: estimating credit cost for an operation, using the specific verb 'estimate' and resource 'credit cost'. It is distinct from sibling tools like get_user_credits and create_credit_checkout_session, which deal with balance and purchase rather than cost estimation. However, it lacks detail on the range of operation types covered.

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 is no mention of prerequisites, such as having an operation in mind, or exclusions like needing to check actual credit balance. Sibling tools are not referenced.

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?

Annotations are all false (readOnlyHint: false, destructiveHint: false), so the description carries the disclosure burden. It explains the prerequisite and classification action but does not reveal side effects like whether it finalizes the garment, consumes handles, or is idempotent. Some scope constraints are added, but deeper behavior remains opaque.

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

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

The description is three sentences, front-loaded with the prerequisite ('Second step only'), and every sentence adds value: prerequisite, action, and exclusion. No fluff 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 no output schema, the description doesn't need to explain return values. It covers the two-step flow, the requirement for prepared/uploaded handles, the classification scope, and explicit non-uses. It could mention that it ultimately creates/updates garment records, but the schema's garments array implies this. Fairly complete for an 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% with detailed field explanations (e.g., upload_handle description, asset_kind enum, processing_mode). The description only restates the classification concept (full/detail front/back/side) without adding new parameter-level semantics beyond what the schema already provides. Baseline 3 applies.

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: 'Second step only for local garment images already prepared with prepare_local_garment_upload' and 'Classify each upload_handle as a full/detail front/back/side asset.' It explicitly distinguishes itself from tools for ChatGPT attachments or public URLs, making it highly specific.

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

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

The description gives explicit usage conditions: 'Second step only' and 'uploaded to every returned target.' It also includes a clear exclusion: 'Do not use this for ChatGPT attachments or arbitrary public URLs.' This effectively tells the agent when to use it versus alternatives.

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

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

Annotations already signal non-read-only/destructive behavior. The description adds meaningful context: the same template and creator path as Uwear, defaulting to the cheapest model, the need to explicitly call save_generated_avatar to persist results, and guidance not to block photoshoots. This goes beyond the annotations without contradicting them.

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 longer than average but every sentence carries essential workflow guidance: purpose, usage context, branch to build_avatar_prompt, model default, and follow-up save step. It is front-loaded with the core purpose and logically organized, with no redundant filler.

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

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

Given the tool has no output schema and 6 parameters, the description provides a complete picture: when to invoke, how it fits with other tools, what to pass, and what happens after generation. It doesn't describe the exact response format, but the candidate/save workflow is sufficiently clear for correct 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 input schema has 100% description coverage for all 6 parameters, so the baseline is 3. The description adds limited new param-specific detail, mostly repeating the model default that already exists in the schema. The guidance about passing prompts directly is more usage-related than 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 'Generate canonical reusable avatar/model design-sheet candidates from the provided person description,' which names the specific verb, resource, and source. It also distinguishes this tool from siblings by referencing the Uwear app template and the follow-up save_generated_avatar 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?

Explicitly states when to use: 'Use when the user has no saved avatars and explicitly asks Uwear to create a reusable model/avatar...' and provides a direct alternative: 'If the user wants help inventing or enriching the person's description, call build_avatar_prompt first.' It also gives a clear exclusion: 'Do not block a normal photoshoot on this; avatar/model is optional.'

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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds the term 'selectable,' which suggests a filtering or state-related behavior not present in annotations, but it is vague. No additional details about not-found behavior or response format are provided.

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

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

The description is a single, concise sentence (7 words) that is immediately understandable. There is no fluff or redundant information, and the key information (get by ID) is front-loaded.

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

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

For a simple get-by-ID tool with one parameter and strong annotations, the description is largely sufficient. However, the term 'selectable' introduces ambiguity about whether non-selectable ArtDirections are excluded, and without an output schema, the description does not clarify the return structure beyond implying the ArtDirection object. This leaves some context missing.

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

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

The input schema already fully describes the single parameter (art_direction_id with type and description). The description's 'by ID' reinforces the parameter's purpose but adds no new semantic detail. Baseline of 3 applies due to 100% 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 (Get) and the resource (ArtDirection) with a specific scope (by ID). It distinguishes from list_art_directions by implying single retrieval, though it doesn't explicitly differentiate from other get_* tools. The word 'selectable' adds a minor qualifier but the core purpose is clear.

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

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

No guidance is given on when to use this tool versus alternatives like list_art_directions or get_art_direction_authoring_job. The description only states what it does, not the context or exclusions. There is no mention of prerequisites or when to prefer this over other retrieval methods.

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

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

The description goes well beyond the annotations by disclosing the asynchronous polling behavior, the terminal statuses ('done or failed'), and the result contents ('authored markdown and, when save=true, the saved art_direction_id'). This adds meaningful behavioral context about what to expect, which is especially valuable given the lack of an output schema.

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

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

The description is two sentences long, with the first sentence immediately stating the tool's purpose and the second providing the essential polling and return details. Every word earns its place, with no redundancy or filler.

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

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

For a simple one-parameter polling tool without an output schema, the description adequately covers the return value for a done job and the terminal statuses. It does not describe the failure response or what happens if the job is not found, but these omissions are likely acceptable for this simple read-only polling 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?

The single parameter job_id is fully described in the schema ('ArtDirection authoring job ID returned by author_art_direction'), and the description reinforces this by referencing the same source. With 100% schema coverage, the description does not need to add further parameter details; it stays at the baseline of relying on the schema.

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

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

The description begins with 'Read an asynchronous ArtDirection authoring job,' which is a specific verb-resource pairing that clearly identifies the tool's purpose. It also distinguishes itself from related tools like author_art_direction and get_art_direction by focusing on the polling/job aspect.

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

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

The description explicitly states when to use the tool: 'Poll the job ID returned by author_art_direction until status is done or failed.' This provides clear usage context and the source of the job_id. However, it does not explicitly mention alternatives or when not to use this tool, such as when a direct art direction fetch would 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?

Annotations already declare readOnly/idempotent/non-destructive, but the description adds essential behavioral context: it loads 'unchanged,' rejects placeholder/guessed IDs, and is not for starting new shoots or editing. This goes beyond the annotation flags without contradicting them.

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

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

The description is four sentences, front-loaded with the core function, then usage rules, then exclusions. Every sentence adds necessary guidance with zero fluff 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?

Despite having no output schema, the description fully covers the tool's purpose, constraints, and relationship to alternatives (update_brief). With one well-documented parameter and rich annotations, no critical information is missing.

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

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

Schema coverage is 100% and the schema parameter description already provides semantics: 'Real persisted brief ID to load unchanged. Do not use 0, guessed IDs...' The description reiterates these constraints but does not add significant new meaning beyond usage context, which is already covered by guidelines. Baseline 3 is appropriate.

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

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

The description opens with a specific verb+resource: 'Load an existing persisted brief unchanged by a real positive brief_id.' It clearly distinguishes from siblings by explicitly stating when to call update_brief instead of looping on get_brief.

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

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

The description provides explicit when-to-use conditions ('Only use when the user supplied that brief_id or after propose_brief/update_brief returned it') and when-not-to-use ('Never use this to start a new photoshoot' and 'call update_brief instead' for modifications). It names the alternative tool update_brief directly.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety profile is covered. The description adds no extra behavioral context (e.g., not-found behavior, return details), but with annotations present, the value added is limited. It does not contradict annotations.

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

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

One short sentence that is front-loaded and earns its place. No wasted words or redundant restating of the tool name.

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

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

The tool is a simple get-by-ID with one parameter and no output schema. Annotations cover the safety profile. The description plus schema is sufficient for an agent to invoke it correctly; no additional detail is essential.

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%: the single parameter garment_id is fully described as 'The garment ID to retrieve'. The description 'a specific garment by ID' adds no new semantic meaning beyond what the schema already provides, so baseline 3 is appropriate.

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

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

The description 'Get a specific garment by ID' clearly states the verb (get), resource (garment), and singular scope (specific, by ID). It distinguishes this tool from siblings like list_garments, which retrieves multiple garments.

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 when you need one garment by ID, but it does not explicitly state when to use this tool versus alternatives like list_garments or update_garment. No when-not-to-use or alternative names are provided, so it only meets the implied usage level.

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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false. The description adds valuable context: returned items are labeled native ImageContent previews, not originals, with detailed semantics for url/download_url/preview_url/poster_url, and that raw payloads are returned when available. No contradiction with annotations.

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

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

The description is dense but information-rich. Every sentence contributes operational value: from preview usage and URL semantics to downstream command integration and date filters. It is front-loaded with the primary lookup purpose before adding deeper 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 17 parameters and no output schema, the description covers essential aspects: result type and preview/original distinction, ID durability for downstream tools, confirmation-gated client flows, date semantics, and raw payload recovery. This is more than sufficient for correct selection and invocation.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond schema by explaining the distinct roles of generation_result_id versus generation_id, demonstrating start_date/end_date usage for natural-language ranges, and describing hybrid search scope. Not all 17 params are discussed, but the schema handles them.

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 looks up generation results by exact IDs, filters, or hybrid image/name/SKU search. It distinguishes itself from siblings by explicitly explaining how its returned identifiers feed into queue_generation_result_qa/read_generation_result_qa and canonical edit/upscale/video commands.

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

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

Provides explicit usage guidance: use generation_result_id for a single result, generation_id to list a job's results, and start_date/end_date for relative requests like 'last week'. It also directs confirmation-gated clients to propose_brief/update_brief/confirm_brief, and clarifies previews vs originals.

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?

Beyond the read-only and idempotent annotations, the description reveals important behavioral details: status may remain 'Created' while queued, previews are not originals (with url/download_url vs preview_url distinctions), and the mapping from UI 'Gemini Pro' to model_slug values. This adds significant transparency beyond the annotations.

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

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

The description is dense and information-rich, front-loaded with the core purpose. It repeats a small amount of schema content (model_slug mapping) but otherwise every sentence provides actionable guidance. Slightly long but appropriately so given the critical warnings about preview URLs and polling.

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

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

With no output schema, the description carries the burden of explaining return values and behavior. It lists key fields, explains preview vs original URLs, warns about polling, and provides model mapping. This is unusually complete for a single-parameter status tool, leaving little ambiguity for an 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?

The schema already fully covers the only parameter (generation_id) with 100% description coverage, so the tool description does not need to add input semantics. It mentions returned fields and model_slug mapping, but these are output-related, not parameter-related. Baseline 3 is appropriate.

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

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

The description clearly states 'Check generation job status' with a specific verb and resource. It distinguishes itself from siblings like get_generation_results and download_generation_results by focusing on status rather than results, and enumerates the returned fields, making the tool's purpose unmistakable.

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

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

The description provides clear usage context: it explains how to handle completed previews, warns against tight polling loops, and clarifies status semantics. However, it does not explicitly mention alternative tools for fetching actual results, so it stops short of fully explicit alternatives/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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description only needs to add context. It does by noting 'grouped by type' and the no-UI workflow context, which informs expected behavior. It does not contradict annotations and adds some value beyond them.

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 crisp sentences: the first states the core function, the second provides workflow context. No wasted words, information is front-loaded and immediately relevant.

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 read-only lookup with two parameters and rich sibling context, the description covers the workflow and return type sufficiently. It could elaborate on the exact grouping structure, but the absence of an output schema is partially mitigated by the description's clarity.

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

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

Schema coverage is 100% with descriptions for both parameters, including allowed values for item_types. The description does not add significant meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description uses specific verb+resource ('Get all item IDs tagged with a specific tag, grouped by type'), clearly distinguishing it from sibling tools like list_tags or propose_brief. The workflow reference further clarifies its unique role.

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

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

Explicitly states when to use ('Use after list_tags for no-UI MCP requests'), provides a concrete example ('use my clothes tagged summer26'), and names an alternative ('instead of opening request_user_context'), giving strong usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the context that the location is 'reusable' and a 'scene reference', but does not disclose any additional behavioral traits such as error handling or response details.

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, front-loaded sentence that communicates exactly what the tool does with no wasted words. Every word adds value.

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

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

For a simple single-parameter read operation with strong annotations, the description is nearly sufficient. It clearly identifies the resource and method, though a brief note about the return value would make it fully complete.

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

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

Schema coverage is 100% and the only parameter 'location_id' is clearly described in the schema. The description adds no new parameter information beyond 'by ID', so it does not elevate above the baseline for full 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 uses a specific verb 'Get' with a clear resource 'reusable location/scene reference' and method 'by ID', making its function unambiguous. It naturally distinguishes itself from sibling tools like list_locations and create_location by implying a single item lookup.

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 (retrieve a location when you have its ID) but provides no explicit when-to-use guidance or mention of alternatives like list_locations for browsing. There is no guidance on when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context that the tool returns version summaries and the live version indicator, which goes beyond annotations but does not disclose additional behavioral traits like pagination behavior (already in schema) or hidden 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 a single concise sentence that conveys the essential purpose without wasted words. It is front-loaded with the verb and resource, making it immediately clear.

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?

This is a simple read-only tool with a rich output schema and full annotations. The description explains the core return value (version summaries and live version), while the schema covers all parameters and the output schema defines return structure. No significant missing context.

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

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

Schema description coverage is 100%, with all three parameters documented in the schema. The description adds no additional parameter-level semantics beyond what the schema provides, so 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 a specific verb ('Read') and a specific resource ('one workflow') with its key aspects ('version summaries and which version is live'). It distinguishes from sibling tools like get_production_workflow_control or list_production_workflows, which serve 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 clearly implies when to use this tool: when you need a single workflow's details, including its version summaries and the live version. It does not explicitly exclude alternatives or name specific siblings, but the context is clear enough given the sibling tool names.

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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that this is a company-level 'kill switch' and that it returns status plus reason, giving useful behavioral context beyond structured annotations. No contradiction with annotations.

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

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

A single, dense sentence communicates the action, target, and output. There is no wasted wording, and the key information is front-loaded ('Read the company kill switch').

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

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

With no parameters and an output schema present, the description is fully sufficient. It explains what the tool reads and what kind of information it returns (stopped/why), so an agent can decide to invoke it without further clarification.

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 zero parameters, so the schema fully covers parameters. Per the baseline for 0-parameter tools, a score of 4 is appropriate since there is no param information needed and the description does not misrepresent anything.

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 uses the specific verb 'Read' and identifies a clear resource: 'the company kill switch' for automation. It explains the purpose: to check whether automation is stopped and why. This distinguishes it from siblings like get_production_workflow (which retrieves workflow details) and update_production_workflow_control (which writes the control).

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 clearly implies when to use this tool: whenever you need to know if automation is globally halted and the reason behind it. It does not explicitly list exclusions or alternatives, but the context is sufficient for a simple read-only status check with no parameters.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds meaningful behavioral context beyond these: it specifies that results are 'stable accepted results' (implying final state, not transient), and it notes that credit movement is included, which is a side effect the caller should be aware of. It also details the data categories returned, providing insight into the response shape without being verbose.

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

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

The description is a single sentence that is front-loaded with the core action ('Read one run in full') and then efficiently enumerates the contents in a list format. Every phrase contributes value, with no redundancy or filler. It is appropriately sized for a tool with one parameter and simple semantics.

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

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

The tool is simple (one parameter, read-only) and has an output schema available, so the description need not explain return values in depth. It lists the main data components included, which is sufficient. However, it does not explicitly disambiguate from closely named sibling tools like get_production_workflow or get_production_workflow_control, though the 'run' context helps. Overall, it is nearly complete for the tool's complexity.

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

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

The input schema has one parameter, workflow_run_id, with a description 'Workflow run ID', giving 100% schema description coverage. The tool description does not add significant meaning beyond identifying the run to read; it equivalently suggests the parameter is the identifier of the run. With high schema coverage, a baseline score of 3 is appropriate, as the description neither enhances nor detracts from the schema's clarity.

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 function with a specific verb and resource: 'Read one run in full'. It enumerates the complete set of data returned (stable accepted results, per-node status, media, errors, retries, credits), which distinguishes it from sibling tools like list_production_workflow_runs (which lists runs) or get_production_workflow (which retrieves a workflow, not a run). The scope is unambiguous.

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

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

The description implies usage when you need full details of a single workflow run, but it does not explicitly state when to use this tool over alternatives such as list_production_workflow_runs for browsing or get_production_workflow for workflow configuration. There is no mention of exclusions or alternative tools. The context is clear but not explicitly contrasted with siblings.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that the full graph is returned and points to a contract resource for typed node configs, which is useful beyond the annotations. No contradiction found.

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 concise sentences: the first states the core purpose, and the second provides a helpful reference to typed node configs and examples. No redundant wording.

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 simple two-parameter schema, full parameter documentation, output schema presence, and annotations, the description plus the contract link makes the tool self-contained for an agent to invoke correctly.

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

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

The input schema already covers both parameters with descriptions (workflow_id and version_id) and 100% coverage. The description adds little semantic detail beyond implying both IDs are needed to identify a single version, so the baseline of 3 applies.

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

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

The description states a specific action ('Read') and resource ('one version's full graph'), clearly distinguishing this from siblings like list_production_workflow_versions or get_production_workflow. The scope is precise: a single version, not a list or summary.

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 gives clear context: use this when you need the full graph of a specific workflow version. However, it does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

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?

Annotations already communicate readOnlyHint, idempotentHint, and destructiveHint. The description adds value by explaining that it loads a 'canonical company template' and by instructing when to pass expected_template_kind to require a specific kind. The mismatch behavior is described in the schema, and the description does not contradict annotations.

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

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

Two sentences, front-loaded with the primary purpose, no filler. Each sentence earns its place: the first states what it does, the second clarifies when to use the optional parameter.

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

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

For a simple read-only get tool, this description is complete. It identifies the input, the optional parameter's usage, and the tool's scope. There is no output schema, but 'load' implies the return of the template object, which is acceptable for a get tool. The annotations cover safety and idempotency.

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

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

Schema coverage is 100%, so parameters are already documented. The description enhances this by explaining the purpose of expected_template_kind ('when the caller requires a generation_preset or batch_workflow'), which adds usage context beyond the schema's 'Optional expected kind.' The template_id is adequately covered by 'by ID.'

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

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

The description states a specific verb and resource: 'Load one canonical company template by ID.' This clearly distinguishes the tool from siblings like list_templates (which lists multiple), save_template (which writes), and delete_template (which removes). The phrase 'canonical company template' adds useful scope.

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 gives clear context on when to use this tool (when you have a template ID and need that specific template) and provides a conditional instruction for the optional expected_template_kind parameter. However, it does not explicitly mention alternatives like list_templates for browsing, so it lacks explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds the context that it retrieves the 'current' balance for the user, which is useful but minimal. It does not contradict annotations.

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

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

The description is a single, clear sentence with no wasted words. It is immediately understandable 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?

For a simple read-only tool with no parameters and rich annotations, the description sufficiently communicates the operation. It does not describe the return format, but given the low complexity, this is an acceptable gap.

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 zero parameters and schema coverage is trivially 100%, so the baseline is 4. The description adds no parameter details because there are none to describe.

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 a specific verb ('Get') and resource ('user's current credit balance'), which distinguishes it from related tools such as create_credit_checkout_session and estimate_cost. It is slightly more specific than the title, though it does not explicitly mention alternatives.

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

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

No guidance is provided about when to use this tool versus alternatives. The description does not mention any exclusions or context for use, leaving the agent to infer from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds behavioral context about the returned format (compact summaries), inclusion of system and company ArtDirections, and query behavior for natural-language requests, which is useful beyond annotations.

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

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

The description is three sentences, front-loaded with the primary function and using each sentence for distinct guidance: output scope, query usage, and follow-up action. No fluff 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?

The tool is a simple list operation with optional parameters and no output schema, but the description covers what is returned (compact summaries), what is included, how to use it in the workflow, and where to go for full details. It is fully contextualized within its sibling set.

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

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

Schema coverage is 100%, so the schema already documents page, limit, and query. The description adds slight nuance by explaining query can match exact names and natural-language creative requests, but this largely mirrors the schema's 'hybrid search' description, so a baseline score is appropriate.

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

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

The description clearly states it lists selectable ArtDirections as compact summaries, specifying the scope (visible system plus company ArtDirections). This distinguishes it from get_art_direction, which is referenced for full documents.

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

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

It explicitly positions the tool as the catalog step before choosing an art_direction_id for a brief and advises a fallback to the user's phrase if no match. It also directs users to get_art_direction for full markdown, providing clear when-to-use and alternative guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description goes beyond by explaining the domain semantics (avatars vs. AI models) and the hybrid search behavior, adding useful context that annotations do not convey.

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

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

Three focused sentences, each adding value: purpose, distinction from sibling, and key parameter guidance. No redundant phrasing or unnecessary detail.

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 tool with 9 optional params and no output schema, the description covers the essential context: what avatars are, the alternative tool, and the critical include_image_url scenario. Pagination and date filters are left to the schema, which is sufficient given the tool's simplicity. It could mention return format, but that's not critical here.

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

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

Schema coverage is 100%, so the baseline is 3. The description echoes the query parameter's hybrid search behavior and the include_image_url usage, but these are already described in the schema. It adds minimal new information beyond what structured fields provide.

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 opens with 'List the user's avatars', a clear verb+resource statement. It further clarifies that avatars are the reusable people/models/mannequins in fashion terms, and explicitly distinguishes from list_models for AI engines, which differentiates it from a likely sibling.

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

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

It provides explicit guidance: 'not the AI engines — for those, use list_models' directly names the alternative. It also gives a concrete usage trigger: 'Set include_image_url=true when the avatar image itself is needed.' This tells the agent when to use the tool and how to configure a key parameter.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, giving the agent a safe read operation. The description adds meaningful context by highlighting the hybrid search across name/SKU/metadata/image-attributes, which is not fully captured by the annotations alone. It also clarifies the user-scoped nature ('user's garments'). No contradiction with annotations.

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

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

The description is a single, tightly packed sentence of 16 words, front-loaded with the primary action ('List user's garments'). Every phrase contributes meaning: the resource, the structured filter option, and the hybrid search scope. No fluff 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 tool's moderate complexity (9 optional parameters, no output schema) and strong annotation coverage (read-only, idempotent), the description is largely sufficient. It communicates the core listing and search capabilities. It could be improved by explicitly noting pagination behavior or directing users to get_garment for retrieving a single known ID, but these are not critical gaps.

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

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

The input schema has 100% description coverage for all 9 parameters, so the schema fully documents each parameter. The description adds only a high-level overview (structured filters vs. hybrid query), which is helpful but does not materially deepen parameter understanding beyond what the schema provides. Baseline of 3 is appropriate.

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

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

The description uses a specific verb 'List' with a clear resource ('user's garments') and explicitly distinguishes the tool's dual capability: structured filters and hybrid search. This sets it apart from siblings like get_garment (single garment retrieval) and upload 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 clearly implies usage context: listing a user's garments, with either predefined filters or free-form hybrid search. It does not explicitly name alternatives such as get_garment for single-item lookups, but the distinction is inferable from the verb 'List' and the two-mode search behavior.

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?

Annotations already mark the tool as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds useful context about the data being 'reusable location/scene reference images' and the user intent, but it does not disclose additional behavioral traits like return format, pagination behavior, or any edge cases beyond what annotations provide.

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 no unnecessary words. The description front-loads the main action and resource, then provides filter details and a use case. Every word earns its place.

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

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

Despite having 9 optional parameters and no output schema, the description is adequate for a list tool: it names the resource, the filter dimensions, and the primary use case. The comprehensive schema covers parameter semantics. It could be slightly more complete by mentioning the return type (e.g., paginated list of location references), but the current coverage is solid.

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 each parameter having a detailed description. The description's summary of filters ('IDs, tags, date range, and sort') offers a high-level abstraction but does not add meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly states the verb 'List' and the specific resource 'reusable location/scene reference images'. It enumerates filter types (IDs, tags, date range, sort) and gives a concrete use case ('pick a saved background/location reference'), which distinguishes it from sibling tools like get_location or create_location.

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 phrase 'Use when the user wants to pick a saved background/location reference for a generation' provides clear context on when to invoke this tool. However, it does not explicitly mention when not to use it or name alternative tools, so it stops short of full usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. Description adds that results include credit costs and clarifies the domain (AI models that render photoshoots), but does not cover response shape, pagination, or rate limits. Moderate value beyond annotations.

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

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

Two sentences, first is action-oriented and specific. Every phrase earns its place; disambiguation is woven in without bloat.

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

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

For a simple one-parameter list tool with read-only annotations, the description fully covers what it lists, the type filter, cost info, and how it differs from list_avatars. No output schema exists, but this is acceptable for a straightforward listing 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% for the single model_type parameter, which already lists allowed values. Description reinforces the 'by type' aspect but adds no new syntax or additional parameter meaning beyond a rough synonym (image/generation).

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

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

Description clearly states the tool lists AI generation models by type, with credit costs. It explicitly distinguishes from human models/avatars and names list_avatars as an alternative, making its purpose unambiguous.

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

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

Provides explicit guidance: use this for AI models, not human models/avatars, and direct users to list_avatars. Also implies usage by model type, aligning with the required model_type parameter.

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

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

The annotations already declare this as read-only, idempotent, and non-destructive, so the description's job is lighter. It adds the definition of outfits and the available filters, but does not disclose return format, pagination behavior, or any side effects. With annotations covering safety, this is adequate but not rich.

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

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

The description is a single sentence that efficiently conveys the core purpose and filter options. It is front-loaded with the action verb and avoids unnecessary details, earning full marks for conciseness.

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

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

The description gives a clear high-level overview but does not mention return structure or pagination behavior. While the schema documents all 10 parameters, the missing output schema means some return expectations are left to the agent; however, for a list operation this is largely inferable, so it is minimally complete.

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

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

The input schema has 100% parameter description coverage, so the baseline is 3. The description's mention of filter types (garment IDs, active status, date range, query) mirrors the schema and adds no new meaning beyond what is already documented.

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 lists the user's saved outfit combinations, using the specific verb 'List' and resource 'outfits'. It further distinguishes the tool by listing the filter capabilities, which sets it apart from sibling list tools like list_garments or list_avatars.

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

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

The description implies the tool is for retrieving outfits and supports filtering, which gives context on when to use it. However, it does not explicitly state when to prefer this over alternatives like propose_outfits or create_outfit_from_garment_ids.

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?

Annotations already establish the tool as read-only, idempotent, and non-destructive. The description adds behavioral traits beyond these—namely the sort order ('newest first') and filterable fields (workflow and status)—which are not visible in annotations or the name alone. No contradiction exists between description and annotations.

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

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

The description is a single sentence of 10 words, front-loaded with the verb and resource, and contains no filler. It efficiently conveys purpose, ordering, and filtering in one concise phrase.

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

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

Given the presence of an output schema and annotations that cover safety and idempotency, the description is sufficient for a straightforward list tool. It specifies the resource, ordering, and filters, leaving pagination details to the input schema and return details to the output schema. No additional context is needed for this simple, read-only 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 already documents all four parameters with descriptions. The description restates that it is filterable by workflow and status, which matches the workflow_id and status parameters, but adds no extra parameter-level semantics beyond what the schema provides.

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

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

The description clearly states the tool lists run history with a specific verb ('List') and resource ('run history'), and includes sorting ('newest first') and filtering capabilities. This distinguishes it from sibling tools like list_production_workflows (which lists workflows) and get_production_workflow_run (which gets a single run).

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 that this is for listing workflow run history, with filtering by workflow and status, which implies its primary use case. However, it does not explicitly name alternatives or exclusions, such as directing users to list_production_workflows for listing workflows, so it lacks explicit when-not-to-use guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, which cover the safety profile. The description adds minimal behavioral context beyond that: it scopes results to 'this company's workflows.' However, it does not disclose pagination behavior, ordering, or that archived workflows are excluded by default (though the schema indicates include_archived default false).

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

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

The description is a single concise sentence with no redundant words. It is efficiently front-loaded with the core action. However, it is almost overly sparse, leaving out useful context, but for conciseness it is well-formed.

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 existence of sibling tools for workflow runs and versions, the description does not help the agent disambiguate when to call this tool. It also lacks any mention of pagination or filtering behavior, though the schema covers parameters. The presence of an output schema does not fully compensate for the missing usage context.

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

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

The input schema provides full descriptions for all three parameters (page, items_per_page, include_archived) with defaults and constraints, achieving 100% schema description coverage. The description itself adds no additional parameter semantics, so 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 function: 'List this company's workflows.' The verb 'list' and resource 'workflows' are specific. It implicitly distinguishes from sibling tools by using the noun 'workflows' rather than 'runs' or 'versions,' but it doesn't explicitly contrast them.

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

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

There is no guidance on when to use this tool versus alternatives like list_production_workflow_runs or list_production_workflow_versions, nor when not to use it. The description only states what it does, leaving the agent to infer usage context from the name alone.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds that the output includes state information, but it does not disclose pagination behavior or any other operational details. This is similar to the baseline case where annotations cover the safety profile.

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

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

The description is a single sentence with no filler or redundancy. It is front-loaded with the main action and resource, making it immediately clear what the tool does.

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

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

The tool is a simple list operation with a well-documented schema, output schema, and strong annotations. The description is sufficient for the agent to understand the core behavior, though it could optionally mention that it returns only versions (not workflow details) and that pagination is handled via page/items_per_page. Given the available structured context, it is adequately complete.

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

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

The schema provides descriptions for all three parameters (workflow_id, page, items_per_page) with 100% coverage. The description does not add any additional meaning or context to the parameters, so the baseline score of 3 applies.

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 that the tool lists a workflow's versions and their state, using a specific verb (list) and resource (workflow versions). It distinguishes from siblings like get_production_workflow_version (which retrieves a single version) and list_production_workflow_runs (which lists runs, not 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 explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It implies usage context (you need a workflow ID) but does not mention that get_production_workflow_version might be more appropriate for a single version.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds behavioral context by outlining a typical workflow (resolving tag names to IDs) and directing to follow-up tools, which goes beyond 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?

Two sentences, front-loaded with the core purpose, and immediately followed by actionable usage guidance. No wasted words.

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

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

For a simple list tool with no output schema, the description fully covers what the tool does, why it's useful (tag resolution), and how to use its output. No gaps remain.

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 zero parameters, and the input schema is empty. The baseline for 0 params is 4 because there are no parameter semantics to explain. The description appropriately focuses on the tool's purpose and usage.

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

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

The description clearly states the tool's function: 'List available tags for the user's company.' This is a specific verb+resource+scope, and it distinguishes from siblings by explaining that this is the tag lookup tool used before other 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?

Explicit when-to-use guidance is provided: 'Use this to resolve user-provided tag names... before selecting garments, outfits, models, files, generations, or locations.' It also gives a concrete alternative: 'For no-UI MCP flows, find the tag ID here, then call get_items_by_tag or the relevant list_* tool with tag_ids.'

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?

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds useful context by explaining that templates do not execute generations and that system templates named 'Demo — …' are worked examples. This goes beyond what annotations provide, without contradicting them.

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, front-loaded with the core action and filters, followed by a domain clarification and a pointer to get_template. Every sentence earns its place with no redundancy.

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

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

For a read-only list tool with no required parameters and no output schema, the description provides sufficient context about templates and their semantics. Pagination and filtering details are covered by the schema, so the description need not repeat them. Slightly more detail on return values could push it to 5, but this is adequate.

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

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

Schema description coverage is 100%, so parameters are already well documented. The description's mention of 'kind, scope, or command use case' loosely maps to template_kind, catalog_scope, and use_case, but adds no new detail beyond the schema. Baseline 3 is appropriate.

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

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

The description starts with a specific verb and resource: 'List canonical company templates' and mentions optional filters by kind, scope, or use case. This clearly distinguishes it from related tools like get_template (read one), save_template (write), and delete_template (remove). The purpose is unambiguous.

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

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

The description provides clear context: templates persist canonical commands and do not execute generations, and it advises reading a Demo template with get_template before authoring. This implies when to use this tool for browsing versus get_template for details, though it does not explicitly state when-not or list alternative 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?

Annotations already indicate a non-read-only, non-idempotent, non-destructive mutation. The description adds useful context about app-only availability and session scoping, but does not disclose potential duplicate behavior or other side effects beyond what annotations imply.

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 front-loaded sentence that conveys all essential information without waste.

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

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

For a simple one-parameter mutation tool with no output schema, the description provides key context (app-only, session-scoped, append behavior) and is sufficiently complete. It does not describe return values, but that is not required given the absence of an output schema.

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

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

Schema coverage is 100% (the single parameter has a description), so baseline is 3. The description adds no extra meaning beyond 'append items' which merely restates the parameter name 'context_items'.

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 ('append'), the resource ('Uwear Shoot Board'), and the scope ('session-scoped'), which distinguishes it from sibling tools like mcp_replace_context (replace) and mcp_clear_context (clear).

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

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

The term 'append' implies adding to an existing board, subtly distinguishing from replace/clear siblings, but there is no explicit guidance about when to use this tool versus alternatives 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?

Annotations already indicate destructiveHint=true and idempotentHint=true. The description adds behavioral value by explaining the all-or-one-type clearing behavior and the 'App-only' constraint. It does not contradict annotations and adds meaningful context beyond what the annotations provide.

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 conveys the essential scope and behavior. Every word adds value, and it is front-loaded with the 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?

For a simple tool with one optional parameter, no output schema, and strong annotations, the description is complete. It fully covers the tool's behavior (clear all or specific type) and the app-only constraint, leaving no significant gaps.

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

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

Schema description coverage is 100%; the parameter 'type' is well-documented with an enum and description 'Context type to remove; omit to clear the entire Shoot Board.' The description's mention of 'one context type' adds no new meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool's function: 'clear all session context items, or only one context type.' It uses a specific verb (clear) and resource (session context items/Shoot Board), and it distinguishes from sibling tools like mcp_add_context and mcp_replace_context by focusing on removal.

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: it's app-only and clears either all context items or a specific type. It implies when to use it (when clearing context is needed), but it does not explicitly mention alternatives or when-not-to-use scenarios. This is clear enough for the simple use case.

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

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

The description adds context about being app-only and user-initiated, but does not disclose the return format or detailed side effects beyond creating a checkout URL. Annotations already cover the safety profile (readOnlyHint false, destructiveHint false), so the description adds moderate value.

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 purpose, and the second sentence adds a usage constraint. Every word earns its place with no fluff.

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

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

The tool is simple (4 optional params, no output schema). The description explains purpose and usage context well. It could explicitly state the return value (the checkout URL) but that is implied by 'create a hosted Stripe Checkout URL.'

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%, and the tool description does not add meaning beyond what the schema already provides for the four optional parameters. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'create a hosted Stripe Checkout URL for buying Uwear credits.' It uses a specific verb ('create') and resource, and distinguishes it from sibling tools like get_user_credits and estimate_cost.

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

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

The description explicitly provides usage context: 'App-only' and 'Hidden from the host LLM so photoshoot planning does not drift into billing unless the user presses the plus button.' This gives a clear when-not-to-use condition. However, it does not name alternative tools for credit checking or estimation.

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?

Beyond annotations (destructiveHint=true), the description reveals that the tool 'spends credits' and is 'hidden from host LLMs,' adding cost and access context. It also discloses the return behavior: 'Returns the generation_id to poll via get_generation_status.' This complements the annotations without contradicting them.

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

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

Three sentences, each earning its place: the action, the credit/access constraint, and the return value. No redundant detail or padding. The most important operational fact (app-only) is front-loaded.

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

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

Despite having no output schema, the description explains the return value (generation_id) and how to follow up (get_generation_status). The credit spend and app-only access are covered. All 4 required parameters are described in the schema, so the description is complete for this tool's complexity.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds little beyond the schema: it references 'user-confirmed montage clips' but does not elaborate on fit_mode, aspect_ratio, or base_resolution. The schema already documents these, so the description does not need to.

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

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

The description states a specific verb and resource: 'export the user-confirmed montage clips as a stitched video.' It clearly distinguishes from siblings like propose_montage and update_montage_proposal by focusing on the final export action. The phrase 'stitched video' specifies the output type.

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

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

The description explicitly states when to use it: 'App-only' and 'the MCP iframe calls this after the user presses Export on the MontageProposal card.' It also excludes host LLMs ('hidden from host LLMs') and mentions the credit cost, which is a key constraint. This effectively differentiates it from proposal-generation 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?

The description adds behavior beyond annotations: it spends credits, is app-only/hidden from host LLMs, queues the generation, and returns a generation_id to poll. This complements the destructiveHint annotation without contradicting it.

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

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

Three sentences with no wasted words. The most important information is front-loaded, followed by the credit-spending caveat and the return value in a logically ordered way.

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 queue-style tool with 9 schema-documented parameters, the description sufficiently explains purpose, usage restrictions, side effects, and how to follow up. The lack of an output schema is mitigated by explicitly mentioning the generation_id and the polling endpoint.

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

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

Schema coverage is 100%, and each parameter already has descriptive text. The description adds no parameter-specific meaning beyond the general image-to-video context, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool queues an image-to-video generation for a montage clip. It names the specific action ('queue'), the resource ('montage clip'), and scope ('App-only'), distinguishing it from sibling tools like propose_montage and mcp_export_montage.

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

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

It explicitly says when to use it: the montage editor calls this when the user presses Generate on a draft clip, and it is hidden from host LLMs, providing a clear when-not. It does not name alternative tools, but the context is strong.

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?

Annotations already declare read-only and idempotent behavior, so the description only needs to add extra context. It adds 'App-only' and 'session-scoped' constraints, which are useful, but 'hydrate' remains vague about whether the tool returns data, initializes the board, or both.

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

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

The description is a single sentence with no wasted words, but it is arguably too terse. The term 'hydrate' could be replaced with more explicit language, yet the structure is clean and front-loaded.

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

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

With no output schema, the description must convey what the agent should expect. It does not explain what a 'Shoot Board' is or what 'hydrate' returns or does, leaving significant ambiguity about the tool's actual effect and return value.

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 zero parameters, so there is no parameter documentation burden. The baseline of 4 applies since the description 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 title 'Get Shoot Board' clarifies the retrieval intent, and the description identifies the resource ('Uwear Shoot Board') and scope ('session-scoped'). The verb 'hydrate' is somewhat non-standard but still conveys loading the board. It is distinguishable from mutation siblings like mcp_add_context, though 'hydrate' adds jargon.

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 given on when to use this tool vs alternatives such as request_user_context or other getters. The 'App-only' label is a constraint, not a usage trigger, and no exclusions or alternative tools 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context about the 'App-only' scope and the workspace files tab, but does not provide additional behavioral details like pagination behavior or return format. No contradictions.

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

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

The description is a single, concise sentence that is front-loaded with the core action and includes the necessary context ('App-only', 'workspace files tab'). No wasted words.

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

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

This is a simple read-only list tool with two optional parameters and no output schema. The description states what it lists but does not describe the return value structure or pagination defaults. Given the low complexity, a brief description is mostly sufficient, but a little more detail (e.g., what fields/objects are returned) 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% (both 'page' and 'limit' have descriptions). The tool description adds no additional meaning for the parameters, so the baseline of 3 is appropriate.

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

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

The description specifies the verb 'list' and the resource 'uploaded files', with a clear context ('Uwear MCP workspace files tab'). It distinguishes from sibling list tools by focusing on 'uploaded files' rather than garments, avatars, etc. However, it could be slightly more explicit about what constitutes a 'file'.

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

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

The description does not provide any explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions. The 'App-only' prefix is a constraint but not a usage guideline. It gives no indication of when to prefer this over other list_* 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?

Annotations already convey destructive and idempotent behavior. The description adds 'session-scoped' and 'App-only', which narrow the scope and provide context beyond what annotations state. This is meaningful incremental value, though it does not detail 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 a single sentence that front-loads the action and includes key constraints. It contains no filler and every word contributes meaning.

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

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

The description, combined with the schema's parameter descriptions, provides sufficient clarity for an agent to understand the tool's purpose, scope, and parameter semantics. The only minor gap is the undefined meaning of 'App-only', but overall it is complete for a replace tool with no output schema.

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

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

Schema description coverage is 100% and both parameters have detailed descriptions, including the precedence relationship between context_items and context_state. The tool description adds no parameter-specific info, so the schema carries the burden, resulting in baseline 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 ('replace') and the resource ('session-scoped Uwear Shoot Board items'). This distinguishes it from sibling tools like mcp_add_context and mcp_clear_context, which have different 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 implies replacement semantics compared to add/clear but does not explicitly name alternatives or provide exclusion criteria. The 'App-only' hint offers some context but does not fully guide an agent on when to select this tool over its siblings.

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

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

Annotations indicate readOnlyHint=false and idempotentHint=false, which align with the write behavior. The description adds context that saves a 'child generation result' and is 'App-only,' clarifying the data model and invocation scope. It could mention return behavior, but annotations cover safety traits adequately.

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 tightly worded sentences immediately establish the tool's restricted audience and purpose. No wasted words; every element contributes essential context.

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

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

For a tool intentionally hidden from host LLMs, the description provides sufficient context for an agent to recognize it as internal. Schema covers required parameters, and the description clarifies the triggering flow. Minor gap: no return value or error behavior described, but given the 'App-only' designation, this is less critical.

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

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

Schema covers all 5 parameters with descriptions, so baseline is 3. The description doesn't add new parameter-level information beyond what's in the schema, though it gives context for image_base64 and parent_generation_result_id through 'user-edited image' and 'child generation result.'

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 function: 'save a user-edited image from the shared ImageDetail retouch editor as a child generation result.' It uses a specific verb and resource, and the 'child generation result' distinguishes it from sibling save tools like save_generated_avatar.

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

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

Explicitly states when to use: 'after the user presses Save.' Also clearly excludes host LLMs with 'Hidden from host LLMs; the MCP iframe calls this,' providing strong context for invocation.

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

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

The description discloses key behavioral traits beyond the annotations: the returned form fields and file_field must be used, local paths must never be sent to Uwear, and a follow-up call is required. This adds essential context about the two-step protocol and response handling, compensating for the lack of an output schema.

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

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

Every sentence in the description serves a distinct purpose: scoping, prerequisites, execution details, security constraint, exclusions, and next-step instruction. It is dense yet efficient, with no redundant or filler content, and the key action is front-loaded.

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

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

Given the tool's complexity (two-step upload process) and the absence of an output schema, the description is remarkably complete. It tells the agent exactly what to do with the response, what to avoid, and what to call next, covering all necessary context for successful 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 input schema already provides comprehensive descriptions for each parameter (file_name, content_type, content_length) with constraints like max length and MIME type enums. The description adds no new parameter-level meaning—it only restates the local path rule already embedded in the schema—so the baseline of 3 for high schema coverage 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 role as the first step for uploading garment images from the host's local filesystem, using specific verbs like 'prepare' and identifying the resource. It also differentiates from sibling upload tools by explicitly excluding ChatGPT attachments and public URLs, making its purpose unambiguous.

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

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

The description provides explicit conditions for use: only when the host can read local files and perform direct multipart HTTP uploads. It also states exclusions ('Do not use this for ChatGPT attachments or existing public URLs') and directs the agent to call finish_local_garment_upload afterward, offering clear guidance.

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

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

Beyond the annotations (destructiveHint=true, etc.), the description discloses significant behavioral traits: commands and immutable plans are persisted without translation, video attachment requires full back/side assets beyond mere upload, and the specific remediation for the video_garment_view_not_attached response. There is no contradiction with the annotations; the description adds context about persistence, validation fallback, and error handling.

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

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

The description is a single dense paragraph, but every sentence carries essential guidance. It is front-loaded with the core purpose, and while it could benefit from bullet points or clearer segmentation, the content is tightly packed and each clause earns its place given 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?

With no output schema, the description does partially cover return behavior by mentioning the BriefProposal creation and the video_garment_view_not_attached error remediation. It covers persistence, execution fallback, and required context. However, it does not fully describe the success return object's structure or other possible error cases, leaving some gap for a tool of this complexity.

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

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

Although schema coverage is 100%, the description adds valuable parameter semantics: it clarifies that model_slug is required for specific command types (generate, edit, upscale, video), explains the use of durable source IDs and reference_attachments, and qualifies when execute_immediately and creative_context should be set. This goes beyond the schema's already rich descriptions, so a score above the baseline of 3 is warranted.

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 opens with a specific verb+resource statement: 'Create a Uwear BriefProposal from canonical generation commands.' It clearly distinguishes the tool from its sibling update_brief by explicitly stating 'For changes to a visible brief, call update_brief with the complete replacement command list.' The title 'Create Brief for Approval' reinforces the purpose without being a mere tautology.

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

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

The description provides explicit when-to-use and when-not-to-use guidance. It names the alternative tool update_brief for modifications, instructs when to set execute_immediately=true (only when the user explicitly asks to run now), and mandates creative_context for photoshoots. It also offers specific constraints like never mixing reference_attachments with img_ref_urls, giving the agent clear operational boundaries.

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

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

The description adds substantial behavioral context beyond the annotations: it clarifies that this tool only PROPOSES a montage for user review (not an actual export), that the user can edit/generate/export later, and that export is free while video generation costs credits. It also details how various parameters affect behavior (trim, generation, speed/mute). With annotations already declaring read-only and idempotent, the description enriches the agent's understanding of the propose-first workflow and cost implications.

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

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

The description is long but every sentence earns its place. It is front-loaded with the critical scoping statement ('ONLY for video montage...'), then systematically covers exclusions, the proposal workflow, per-item semantics, and cost behavior. The structure flows logically from when-to-use to how-to-invoke, and there is no redundant filler.

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

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

The tool is complex (nested MontageItemInput with 13 sub-properties, mixed video/image handling), yet the description covers all major aspects: item types, required fields, trim semantics, duration handling for image vs video, audio generation, aspect ratio, resolution, credit costs, and the post-proposal flow. The absence of an output schema is compensated by explaining the proposal-review-confirm sequence. This is as complete as one could expect for such a 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?

Even though schema coverage is 100%, the description adds meaningfully beyond the schema: it explains how to interpret user requests like '3 seconds each' into setting target_duration: 3 on every item, instructs to tailor per-image motion prompts and avoid generic repeated prompts, and advises inspecting the image with view_image when motion isn't specified. These are practical parameter-usage rules that go beyond the raw field descriptions.

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

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

The description clearly states the tool's sole purpose: video montage/stitching/export workflows, and that it PROPOSES a montage for user review. It explicitly differentiates from sibling tools like propose_brief and mcp_export_montage, and enumerates the exact trigger phrases ('create a montage', 'stitch clips', 'make a reel', etc.). This is a specific verb+resource with strong sibling differentiation.

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

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

The description provides explicit when-to-use guidance, including exact user request patterns, and equally explicit when-not-to-use exclusions (photoshoots, lookbooks, product shoots) with the correct alternative path ('request_user_context followed by propose_brief/update_brief'). It also warns against calling the tool merely because images exist in context, and clarifies that photoshoots must first be proposed as a BriefProposal. This is textbook usage guidance.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, so the safety profile is clear. The description adds behavioral value by disclosing return contents ('candidate titles, clothing_item_ids, and short rationales') and the correct follow-up action, which are not present in annotations. It doesn't contradict any annotations.

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