prompt-to-asset

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

Annotations already declare readOnlyHint=true and idempotentHint=true, signaling safe, idempotent operation. The description adds the context that it parses into a specific schema, which goes beyond the annotations. 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, well-structured sentence that conveys the tool's purpose and inputs without unnecessary words. It is front-loaded with the verb and resource.

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

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

Given the tool's simplicity (one parameter, no output schema needed) and clear sibling context, the description is fully adequate. It specifies input types and output target, making the tool's usage unambiguous.

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 a single parameter. The description enriches the parameter's meaning by listing example source formats (brand.json, DTCG tokens, etc.), providing actionable context beyond the schema's bare description 'Path to file or raw text'.

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 specifies the verb 'Parse', the resource 'brand source', and lists specific formats (brand.json, DTCG tokens, AdCP spec, brand.md, raw text). It also states the output target 'canonical BrandBundle schema', distinguishing it from sibling tools that generate or edit assets.

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 this tool is for converting brand source files, but it does not provide explicit guidance on when to use it versus alternatives, nor does it mention prerequisites or excluded scenarios. Usage is implied but not clearly directed.

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 and idempotentHint. The description adds 'Read-only; no network,' reinforcing safety and disclosing environmental constraints. This aligns with and supplements annotations without contradiction.

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 functionality, the second gives usage instruction and behavioral notes. No superfluous words; information is front-loaded and efficiently presented.

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 capability check with one optional parameter and no output schema, the description fully covers what the agent needs: what the tool does, when to call it, and environmental constraints. The return format is implied (list of modes), which is sufficient.

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

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

The sole parameter asset_type has 100% schema description coverage, and the description repeats the schema's explanation verbatim ('Narrow the modes-by-asset-type section to one type'), adding no new meaning. 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 indicates the tool reports which execution modes the server can run, listing three specific modes (inline_svg, external_prompt_only, api). This verb+resource purpose is distinct from sibling tools that generate or ingest assets.

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 says 'Call before offering the user options,' providing clear guidance on when to use. It does not explicitly say when not to use or name alternatives, but the context of sibling tools implies it is a preliminary check before mode selection.

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

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

Beyond the `openWorldHint` annotation, the description discloses that the tool is read-only by default, and details the side effects of enabling `auto_fix` (installing binaries, never sudo). It is fully transparent about the tool's behavioral traits.

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

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

The description is a single paragraph that front-loads the purpose and output list, then covers parameters. It is somewhat verbose but well-structured and every sentence adds value.

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

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

Given no output schema, the description fully explains what the tool returns (a list of statuses, routes, keys, hints, etc.) and how to use its parameters. It is complete for an environment inventory tool with three optional parameters.

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% (all three parameters have descriptions). The description adds significant value by explaining the purpose and context of each parameter beyond the schema, e.g., that `check_data` runs an integrity check and `auto_fix` uses specific package managers.

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 identifies the tool as a 'structured environment inventory' MCP equivalent of `p2a doctor`, and lists specific outputs (native-dependency status, routes, keys, etc.). It distinguishes itself from sibling tools that focus on asset generation or model inspection.

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

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

The description explains when to use each parameter (e.g., check_data for CI after data edits, auto_fix to install missing binaries, auto_fix_dry_run for preview). It does not explicitly contrast with sibling tools or provide 'when not to use' guidance, but the context is 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?

Adds value beyond annotations by describing the clarifying questions array and modes reporting behavior. Annotations already indicate read-only and idempotent, and description reinforces that consistently.

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 front-loaded with the main purpose, but it packs multiple aspects into one sentence. Could benefit from bullet points for clarity, but 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?

Output is well-described (modes_available, clarifying_questions), but several input parameters lack explanation in both schema and description. No output schema exists, so the description partially compensates but is incomplete regarding input semantics.

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?

Only adds meaning for 'brief' (plain-English) and implicitly for 'target_model' (force model). With 43% schema coverage, the description does not adequately explain parameters like vector, asset_type, brand_bundle, etc.

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 classifies, routes, rewrites, and reports execution modes, distinguishing it from sibling generation tools by being a preprocessing step that returns an AssetSpec rather than an actual asset.

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 advises surfacing clarifying questions before calling a generator, and notes the tool is read-only and idempotent. However, it does not explicitly state when to use it over siblings like asset_capabilities.

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 annotations: no API key required, runs on sharp, resizes input to RGBA 1024², and uses a unique default output directory to avoid clobbering. This adds value as annotations only have openWorldHint: 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 three sentences long, all relevant. The first sentence states the core function, the second provides the MCP equivalent, and the third gives usage conditions. No wasted words.

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

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

Given the moderate complexity, 7 parameters with full schema coverage, and no output schema, the description adequately covers why, when, and basic behavior. It could be improved by briefly noting that output is a set of platform-specific bundles, but overall it is 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?

Schema coverage is 100%, so the parameters are already well-documented. The description adds minimal additional meaning beyond the schema, such as the default for bg being white and out_dir being timestamped. 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 fans out a 1024² master PNG into multiple platform bundles, listing specific platforms (iOS, Android, PWA, etc.). It provides the MCP equivalent command and distinguishes from siblings by specifying the comprehensive bundle generation, unlike single-icon tools like asset_generate_app_icon.

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: when the LLM has a master PNG from various sources and needs the platform fan-out. It does not explicitly mention when not to use or list alternatives, but the context is clear enough for an agent to decide.

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 in non-api modes only the master mark is produced and requires calling `asset_ingest_external` for fan-out. It also explains the effect of `ios_18_appearances`. The `openWorldHint` annotation is not contradicted. However, it does not mention any other side effects or error conditions.

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

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

The description is a single paragraph that covers the essential workflow in a compact manner. It could be split into bullet points or sections for readability, but the information density is appropriate.

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

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

The description covers the main workflow and references the sibling `asset_ingest_external` tool. However, it lacks explanation for `brand_bundle` and `output_dir` parameters. Given 6 parameters and no output schema, more detail would improve completeness.

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

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

With only 17% schema description coverage, the description compensates by explaining `mode`, `platforms`, and `ios_18_appearances` beyond the schema. However, it does not explain `brand_bundle` or `output_dir`, leaving gaps. The `brief` parameter is implied but not described.

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 generates app icons for multiple platforms (iOS, Android, PWA, visionOS) and specifies three modes. It distinguishes itself from sibling tools like `asset_generate_favicon` and `asset_generate_hero` by detailing platform-specific outputs and the need for post-processing via `asset_ingest_external` in non-api modes.

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

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

The description explains when to use each of the three modes and the post-processing step for non-api modes. It also mentions the `ios_18_appearances` feature. However, it does not explicitly state when not to use this tool or compare it to alternatives like `asset_generate_logo`, slightly reducing clarity.

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?

Description discloses output files (favicon bundle) but does not detail side effects or state changes. Annotation 'openWorldHint: true' is consistent, but additional behavioral context (e.g., whether it modifies input assets) is missing.

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 states purpose and output, second gives mode guidance. No redundant information; every sentence adds value.

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

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

Despite no output schema and low parameter coverage, the description does not fully compensate. It lacks detail on required input semantics and does not clarify the roles of nested objects or optional parameters, making the tool less complete for autonomous 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 0%, yet the description only explains the 'mode' parameter (three values) and hints at output. Other parameters like 'brief', 'brand_bundle', 'existing_mark_svg' are not explained, leaving the agent with insufficient semantic understanding.

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

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

Clearly states 'Generate a favicon bundle' and lists specific output files, distinguishing it from sibling tools like logo or app icon generators. Mentions three modes, with inline_svg recommended for simple glyph marks.

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 guidance on when to use each mode ('inline_svg is the best fit for simple glyph marks') but does not explicitly contrast with sibling tools or give when-not-to-use advice.

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 significant behavioral detail beyond the minimal annotation (openWorldHint: true): it discloses two operation modes, unsupported inline_svg, accepted aspect ratios, brand bundle injection, and variant return behavior. This informs the agent effectively.

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

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

The description is three terse sentences: first states purpose, second details modes and unsupported, third lists options and return behavior. Every sentence adds value, with no waste, and the key information 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?

It covers the main purpose, modes, key parameters, and return behavior. The missing details (description of brief and output_dir) are minor since brief is the required input and output_dir is a standard file path. No output schema exists, but the description implies return of variants. Slightly incomplete but acceptable.

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

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

The description adds meaning to four of six parameters (mode, aspect_ratio, brand_bundle, count) by listing allowed values and behavior. The remaining parameters (brief, output_dir) are not described but their purpose is inferable from context (brief is the prompt, output_dir for output). This compensates well given no schema descriptions.

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

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

The description explicitly states it generates 'marketing-hero / landing-page banner art', which is a specific verb-resource pair. This clearly distinguishes it from sibling tools like asset_generate_logo or asset_generate_app_icon.

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 mentions two modes and unsupported inline_svg, providing some guidance on when to use each mode. However, it does not explicitly state when not to use this tool compared to alternatives (e.g., for logos or icons), nor does it provide exclusion criteria.

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

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

The description discloses the brand injection behavior and the unsupported inline_svg, adding value over the openWorldHint annotation. However, it does not address auth needs, side effects, or rate limits, and the openWorldHint suggests potential mutations not fully explained.

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

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

The description is concise with two front-loaded sentences, no redundant phrases, and efficiently conveys the core functionality and key constraints.

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

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

Given the lack of output schema and low schema coverage, the description covers the main purpose and modes but omits details on parameter behavior (count, aspect_ratio, output_dir) and return values. It is adequate for basic understanding but not fully self-contained.

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

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

With 0% schema description coverage, the description compensates by explaining the mode parameter (two values) and brand_bundle (brand injection). However, it does not add semantics for count, aspect_ratio, or output_dir, leaving significant gaps for a 6-parameter tool.

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 'Generate' and the resource 'brand-locked illustrations', and specifies two modes and brand injection. It distinguishes the tool from siblings by the brand-locking aspect and the unsupported inline_svg, making the purpose very 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 mentions two modes but does not provide guidance on when to use one over the other, nor when to avoid this tool in favor of siblings like asset_generate_logo. The constraint about inline_svg is helpful but not a complete usage guideline.

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 sole annotation (openWorldHint=true), the description discloses key behavioral traits: mode-specific key requirements, auto-selection logic, and that the return is a discriminated union (AssetBundle/InlineSvgPlan/ExternalPromptPlan). This adds substantial context for agent decision-making.

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, each adding unique value: purpose, mode breakdown, and return type. Information is front-loaded and no sentence is wasted.

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?

While the description covers modes and returns, it omits explanation of most input parameters (e.g., what 'brief' expects, how 'brand_bundle' affects output). For a tool with 6 parameters and no output schema, this leaves significant gaps for an agent to understand invocation fully.

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

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

The description explains only the 'mode' parameter (three values and auto-select), which is the only parameter with schema coverage (17%). Other critical parameters like 'brief', 'brand_bundle', and 'text_content' are not described, leaving the agent without guidance on their roles.

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

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

The description clearly states 'Generate a logo' and elaborates on three distinct modes (inline_svg, external_prompt_only, api) with specific behaviors. This distinguishes it from sibling tools like asset_generate_hero or asset_generate_illustration, which have different asset targets.

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

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

The description explains when to use each mode and that omitting the mode auto-selects. However, it does not explicitly advise against using this tool in scenarios better suited for siblings (e.g., generating a hero image), nor does it provide exclusion criteria.

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

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

Adds substantial behavioral context beyond annotations: deterministic typography, no diffusion, server-side without API key, unsupported inline_svg mode. Informs agent about tool limitations and rendering behavior.

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

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

Three sentences, front-loaded with purpose, no redundant information. Each sentence 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 good purpose and transparency, the description omits details for most parameters (6 of 8 undocumented), and no output schema or return value description. Given 8 parameters and nested objects, the description is incomplete for full parameter understanding.

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

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

Adds meaning for mode and with_background_image (inline_svg unsupported, external_prompt_only conditional). However, 0% schema coverage means other parameters (title, subtitle, template, brand_bundle, background_brief, output_dir) are left undescribed. Partial compensation but not comprehensive.

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 output ('Render a 1200×630 OG image'), method ('via Satori template'), and key characteristics ('deterministic typography, no diffusion'). Distinguishes from diffusion-based generation tools among siblings.

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

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

Provides guidance on mode usage: api is default and server-side, inline_svg is not supported, external_prompt_only is conditional on with_background_image. Lacks explicit comparison to sibling asset generation tools but is clear enough for its specific purpose.

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

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

The description lists output files and states that inline_svg is not supported. However, with only openWorldHint: true in annotations, it does not specify behaviors like file overwriting, permissions, or network calls. The added detail 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 concise (two sentences), front-loads the purpose, and efficiently delivers constraints and output details without redundancy.

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

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

Given the tool's complexity (7 parameters, nested objects, multiple platforms, multiple output files), the description covers the core workflow, key constraints, and output file list. It lacks details on some parameters but is largely complete for a generation tool.

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

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

Schema description coverage is only 14%; the description adds meaning to existing_mark_svg (preferred path) and explains mode values. It does not elaborate on brief, brand_bundle, or output_dir, leaving gaps in understanding.

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

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

The description clearly states the tool's purpose: generating a cross-platform splash-screen bundle from a brand mark. It specifies that inline_svg is not supported and outlines the output files, distinguishing it from sibling tools like asset_generate_app_icon.

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

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

The description explains the prerequisite: first generate a logo inline_svg then call this tool with existing_mark_svg. It also mentions two modes but does not elaborate on when to use each. It provides clear context for use.

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

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

The description outlines the pipeline steps but lacks details on side effects, permissions, what happens to the input image, or output format. Annotations are minimal, so description should compensate but does not.

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, concise and front-loaded, but could better structure the pipeline steps and parameter 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?

With 7 parameters, low schema coverage, no output schema, and a multi-step pipeline, the description is incomplete. It omits parameter semantics and does not explain 'tier-0 validation' or output.

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

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

Schema coverage is only 14%, and the description adds no parameter explanations beyond the pipeline mention. It does not describe brand_bundle, expected_text, vector, transparent, or output_dir.

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 ingests externally generated images and runs a specific pipeline (matte, vectorize, validation), distinguishing it from sibling generation tools.

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

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

The description provides context by listing external tools and mentioning 'round-trip endpoint for external_prompt_only mode', but does not explicitly state when not to use it or name 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?

Discloses auto-detection of framework, return of platform hints, and that it does not handle IDE registration. 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 (three in original) front-load the action and add key usage context without redundancy.

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

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

With 8 parameters and no output schema, the description covers when and why to use it. Missing detail on return format, but sufficient 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 coverage is 100%, so description adds minimal value beyond naming parameters. However, it contextualizes the overall tool purpose.

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

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

Clearly states the verb 'scaffold' and the resources 'brand.json' and 'assets dir.' Differentiates itself from sibling tools like asset_generate_app_icon by specifying it's the initial setup step.

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 says 'call this at the start of a new project' and explains what it deliberately does not do (IDE MCP registration), guiding the agent to use other tools after.

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 provide readOnlyHint and idempotentHint. Description adds return fields (ModelInfo record, env status, etc.) and confirms no network, providing useful behavioral context 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?

Three sentences with no waste. First sentence states purpose, second clarifies input, third lists outputs. Information is front-loaded and efficiently presented.

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

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

Despite no output schema, the description lists return fields comprehensively. Single parameter, low complexity, and all critical information (inputs, behavior, outputs) are covered, making it complete for an agent to understand.

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 the 'id' parameter fully. Description adds semantic value by noting alternative identifier (aka alias) and providing examples, enhancing understanding beyond schema alone.

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 inspects one model and provides a full capability dump. It distinguishes from sibling 'asset_models_list' via the verb 'inspect' and mentions the MCP equivalent command, making 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?

Description specifies accepted inputs (model id or aka alias) and states read-only behavior. While it doesn't explicitly mention when not to use or compare to alternatives, the context is clear enough for basic 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 and idempotentHint; description adds 'Read-only; no network' and lists return fields (id, family, provider, etc.) which provides additional behavioral context 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?

Three concise sentences: first states purpose and size, second lists return fields, third lists filters. Front-loaded with purpose, no wasted words.

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

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

Given the simplicity of a filtered list tool with full schema coverage and annotations, the description is complete: it details return fields, filter options, and safety. No output schema needed; description covers return values.

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 each parameter has a description. The description merely lists filter flags by name without adding new meaning or usage guidance 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?

Description clearly states 'List the model registry' with size and optional filters, uses a specific verb and resource, and distinguishes from sibling 'asset_models_inspect' which likely inspects a single model. Also provides MCP equivalent command for context.

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

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

Description notes 'Read-only; no network' but does not explicitly state when to use this tool versus alternatives like other list or generation tools. No exclusions or when-not-to-use guidance 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?

Discloses key behavioral traits: emits multiple output formats and optionally an Android .9.png file. No contradictions with annotations. Could mention overwriting behavior or return value, but overall good 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?

Two sentences, front-loaded with core purpose and outputs. No unnecessary words. Efficient and 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?

Covers main inputs and outputs, but lacks details on return value, error handling, or formatting constraints. Adequate for a generation tool but with room for improvement.

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. Description reinforces parameter meanings by mentioning 'one image and 4 pixel offsets' but does not add significant 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?

Description clearly states the tool emits a 9-slice config, CSS border-image snippet, and game-engine-ready numbers from one image and pixel offsets, with optional Android .9.png output. It distinguishes itself from sibling tools by focusing on nine-slice generation.

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

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

Implied usage for generating nine-slice data from an image, but lacks explicit when-to-use or when-not-to-use guidance, nor comparisons to sibling tools. The MCP equivalent reference provides some context.

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

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

Description adds some behavioral context (remote endpoint, local fallback, returns path). However, annotations declare readOnlyHint=true, while the tool creates an output file (RGBA PNG), which is a write operation. This contradiction reduces transparency. Without annotations, the description would be sufficient, but the mismatch harms credibility.

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

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

Single sentence, 20 words, front-loaded with the core action. Every word earns its place—techniques and output format are included without redundancy.

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

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

Input schema is simple (3 params, 1 required, no output schema). The description covers the main behavior and return value but omits details about the output_dir parameter and potential side effects. Given the low complexity, a score of 3 reflects adequate but not thorough coverage.

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 33% (only image has a schema description). Description maps mode enum values to algorithm names (BiRefNet, RMBG, U²-Net), adding meaning beyond the enum list. However, output_dir is not explained. Baseline 3 is appropriate since description partially compensates for low 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 tool removes background from an image ('matte an image to transparent background') and returns an RGBA PNG path. It references specific algorithms and fallback behaviors, making the purpose unambiguous and distinct from sibling tools like asset_upscale_refine or asset_vectorize.

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

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

No explicit guidance on when to use this tool versus alternatives. The description does not mention prerequisites, limitations, or contrast with similar tools such as asset_generate_logo or asset_sprite_sheet. Usage context is left entirely to the agent's inference.

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

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

Discloses that it writes multiple files to disk, validates SVG against original brief, and returns an AssetBundle. Provides sufficient behavioral detail given limited annotations (only openWorldHint=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?

Front-loaded with purpose and usage trigger. Each sentence adds value, though the paragraph is dense and could be better structured with bullet points for clarity.

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

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

Covers main workflow, validation, and output files. Could elaborate on optional parameters like brand_bundle and expected_text, and since there's no output schema, more details on return structure would help.

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?

Adds value beyond schema by mentioning validation details (viewBox, path count, etc.) and listing output files. Schema coverage is 60%, and description compensates with context on svg parameter and overall behavior.

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

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

Clearly states it is a round-trip endpoint for inline_svg mode, explaining that it writes asset bundles from SVG text emitted in chat. Distinguishes itself from sibling tools (e.g., asset_generate_logo) by focusing on saving already generated SVGs.

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 tells when to use: immediately after emitting SVG in chat. Does not explicitly state when not to use or list alternatives, but purpose and sibling names imply alternatives for different tasks.

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 minimal (only openWorldHint: false). Description mentions 'Offline, no API key' but does not disclose behavior like file creation, write permissions, or side effects. It conveys output format but lacks full behavioral clarity expected for a tool with few 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 with no wasted words. First sentence explains core functionality and output, second adds context (CLI equivalent and offline). Information is front-loaded and efficient.

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

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

Lacks details about the return value (what the tool returns after execution). While the output files are described, the immediate result to the agent is not specified. Given no output schema, this is a gap. Otherwise, the description covers most 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?

Schema description coverage is high (67%), and the schema itself documents each parameter adequately. The description adds no extra meaning beyond stating input formats. Therefore, it meets baseline but does not improve upon schema.

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

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

Description clearly states it packs a directory of frames into a sprite sheet and JSON atlas, specifies supported formats (PNG/WEBP/JPG), and mentions compatibility with multiple game engines. It distinguishes itself from sibling tools which are about brand assets and icons.

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?

Implicitly indicates usage for game development by listing compatible engines, but does not explicitly state when to use or when not to use this tool compared to alternatives. No sibling does sprite sheet packing, so it's unique, but explicit guidelines are missing.

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 behaviors: external HTTP call, packaging/validation, and output (lora_id). Annotations only provide openWorldHint, so the description adds value beyond structured fields.

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-loading the purpose, then adding requirements and context. No wasted words, but could be slightly more concise.

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

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

For a training tool with 6 params and no output schema, the description covers inputs, process, output, and external dependencies, referencing more detailed docs. Lacks explicit return format but acceptable.

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

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

Schema coverage is 67%; the description adds meaning for 'name' and 'training_images' but not for 'rank' and 'steps', which are only given defaults. Some param info is provided but not comprehensive.

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 trains a brand-consistent LoRA from sample images and returns a lora_id, with a specific verb and resource, distinguishing it from siblings focused on asset generation/ingestion.

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

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

The description explains the tool requires a user-owned training endpoint and references documentation, but does not explicitly state when not to use or list alternatives among 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?

The description claims a write operation ('upscale / refine') but annotations set readOnlyHint=true, creating a direct contradiction. No additional behavioral context (e.g., permissions, side effects) is disclosed.

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 concise sentences, front-loaded with the core purpose, and every sentence adds meaningful information without extra fluff.

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

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

Given 5 parameters, no output schema, and an annotation contradiction, the description is insufficient. It does not clarify return values, explain all parameters, or resolve the readOnly inconsistency.

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

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

With 0% schema description coverage, the description adds value by explaining the mode enum's algorithms (DAT2, Real-ESRGAN, etc.) and ties asset_type to algorithm selection. However, it does not explain target_size, output_dir, or image format.

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 upscales/refines images with asset-type awareness, listing specific algorithms for different types. This verb+resource combination distinguishes it from sibling tools like asset_generate_logo or asset_remove_background.

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 upscaling/refinement but does not explicitly state when to use it over alternatives or when not to use it. No exclusions or sibling comparisons 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 already declare readOnlyHint and idempotentHint. The description adds detail about deterministic validators and optional VLM, but does not disclose potential side effects or performance implications 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 dense sentences that front-load the main purpose and list validators. No redundant information.

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

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

Given no output schema and complex nested parameters (brand_bundle), the description fails to explain return values or the structure of brand_bundle. It lacks completeness for effective agent 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?

With 0% schema description coverage, the description compensates partially by explaining brand_bundle (palette ΔE2000), intended_text (OCR Levenshtein), and run_vlm (VLM-as-judge). However, image and asset_type are not described.

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 runs tier-0 deterministic validators on an asset, listing specific checks (dimensions, alpha, checkerboard, etc.) and optional VLM-as-judge. This distinguishes it from sibling generation/export 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?

No guidance is provided on when to use this tool versus alternatives like asset_doctor or asset_capabilities. No prerequisites or use cases 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?

The description contradicts the readOnlyHint annotation by describing a transformation that likely creates an output file, implying a write operation. This is a serious inconsistency. Additionally, while it mentions fallback strategies, the contradiction undermines trust.

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 sentence adds value. No extraneous information.

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

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

Given the tool's complexity (5 parameters, fallback logic, SVGO), the description omits parameter semantics, return value details, and output expectations. Without an output schema, the agent lacks critical context for effective use.

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

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

With 0% schema description coverage and no parameter explanations in the description, the agent must rely solely on parameter names. The description adds no semantic value beyond the schema, leaving 5 parameters (especially mode, palette_size, max_paths) underexplained.

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 'Convert a raster image to SVG' with a specific verb and resource. It distinguishes from sibling tools like asset_upscale_refine and asset_remove_background by focusing on vectorization.

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 details the fallback order (Recraft, vtracer, potrace, posterize) and conditions for each, providing clear context on how the tool operates. However, it does not explicitly state when to use this tool over alternatives or when not to use it.

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