Nano Studio Pro

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

Annotations already mark destructiveHint=true, but the description adds specific behavioral details: the need for user confirmation and the non-refundable credit policy. This goes beyond the annotation and helps the agent understand consequences.

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, efficient sentence that conveys the core action and critical caveats. No wasted words; the warning is front-loaded and impactful.

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 cancellation tool with one parameter and no output schema, the description covers the action, side effects, and user confirmation. It lacks details on return values, but that's acceptable given the simplicity and the annotations.

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 task_id is self-explanatory, but the description does not explicitly explain its meaning or format. With 0% schema coverage, the description could have added a line like 'task_id is the ID of the running task to cancel,' but the name is clear enough.

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 cancels a running task, with a specific verb and resource. It distinguishes from siblings like retry_task or get_task by specifying 'running task', implying it only applies to tasks in progress.

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 usage context: confirm with the user first and warns about non-refundable credits. It doesn't explicitly state when not to use it or mention alternatives, but the guidance is actionable for the agent.

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=false and destructiveHint=false. The description adds 'Returns its id' and 'Free' (cost indication), which are useful behavioral details beyond the annotations. It does not cover permissions or side effects, but for a simple create operation, this is acceptable.

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 short, purposeful sentences: action, return value, and cost. Each sentence contributes distinct information with no redundancy, and the 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?

For a simple create operation with one parameter and no output schema, the description provides essential information (returns id) and is complemented by annotations. It lacks details on error conditions or prerequisites, but these are minor 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?

The schema describes the only parameter 'name' with a length constraint, and the description adds no additional parameter details. Since schema coverage is 100%, 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?

States a clear verb+resource: 'Creates a new project' and adds return info ('Returns its id'). It is easily distinguished from siblings like list_projects and get_project because it explicitly mentions creation.

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 mention when to use this tool versus alternatives, such as resolve_project or list_projects. The usage is implied by the name, but there is no explicit guidance on exclusions or when to prefer other 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 provide readOnlyHint=false and destructiveHint=false, but do not disclose the cost implications. The description explicitly warns 'COSTS CREDITS', which is valuable beyond annotations. However, no other behavioral details (e.g., credits amount, processing time) are given, so a middle score is appropriate.

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 exceptionally concise, with two sentences that pack essential information: the output, the cost warning, and the source constraint. Every word serves a purpose, and critical constraints are 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 4 parameters with 0% schema coverage and no output schema, the description is somewhat incomplete. It explains the source constraint but not project_id's role or what the output 'clean plate' means practically. The cost warning is helpful but more context on expected behavior is needed for a full picture.

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%, meaning the schema provides no descriptions. The description mentions that exactly one of generation_id, asset_id, or url must be used, which adds meaning, but it does not clarify the purpose of project_id or the relationship between the three source parameters. This partially compensates for the schema gap but leaves gaps.

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

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

The description clearly states the tool's purpose ('subject cutout') and its output (transparent PNG + clean plate), but it does not explicitly distinguish itself from sibling tools like get_cutout or expand_image, which could be confused for similar operations.

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

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

The description provides a key usage guideline: exactly one of generation_id, asset_id, or url must be provided, which is crucial. However, it does not explain when to use cutout versus alternatives like expand_image or restyle, leaving some ambiguity.

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=false and destructiveHint=true. The description adds the important behavioral detail that deletion is permanent and that user confirmation is required, which goes beyond the annotation 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?

The description is a single concise sentence with the core action front-loaded and the critical warning appended. Every word earns its place; there is 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 simple destructive tool with one parameter and no output schema, the description covers its purpose, permanence, and user-confirmation requirement. It is sufficient for correct invocation, though it could mention error cases or asset-not-found behavior.

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%, and the description does not explain what asset_id specifically refers to or how to obtain it. The word 'asset' provides minimal context but does not compensate for the lack of parameter documentation.

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, 'Permanently deletes an asset,' with a clear resource and scope. It contrasts with siblings like get_asset, list_assets, and upload_asset by making the destructive intent explicit.

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 warning 'DESTRUCTIVE — confirm with the user first' provides clear context for when this tool should be invoked, emphasizing user confirmation. It does not explicitly enumerate alternatives, but the delete-versus-read/write distinction is evident from the tool name and sibling set.

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 significant behavioral detail beyond sparse annotations: costing credits by output resolution, creating a NEW generation in the source's own project (side effect), and optional zoom/extend behavior. This is exactly the kind of context that helps an agent anticipate side effects and costs, and it does not contradict readOnlyHint=false or destructiveHint=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?

Three sentences, each carrying distinct information: the core operation, the cost/side-effect warning, and optional parameter usage. No fluff, and the most critical behavioral notes are front-loaded. Slightly compact but appropriately 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 mutation tool with a nested object, enums, no output schema, and sparse annotations, the description covers the key aspects: side effect (new generation), cost, and optional parameter behavior. It does not mention the return value or whether the operation is async, but enough is provided for correct invocation in most cases.

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

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

The schema already describes zoom, extend, and resolution with decent detail (60% coverage). The description adds a little emphasis on 'zoom < 1' and 'restrict directions with extend' but does not clarify generation_id or target_aspect_ratio beyond the schema. With 60% coverage, the 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 a specific verb ('outpaints') and resource ('existing generation') with a defined outcome (bigger canvas / new aspect ratio). It distinguishes the tool from siblings like upscale_image (which increases resolution) and generate_image (which creates from scratch) by focusing on extending the scene beyond original edges.

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?

Usage context is implied: use this when you need to expand an existing generation to a larger canvas or new aspect ratio. It mentions optional controls for restricting directions and zooming out, but does not explicitly name alternatives or state when not to use it, leaving some routing to 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses important behavior: it costs credits, returns the image inline with id and credits_remaining, and supports references. This adds meaningful context about side effects and performance that annotations alone 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?

The description is dense but every sentence earns its place, front-loading the core function and cost warning before model guidance. The semicolon-separated model guidance is compact and readable despite covering multiple variants.

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 six parameters, three enums, no output schema, and the readOnly/destructive annotations being neutral, the description covers cost, return format, model choice, reference limits, and resolution constraints. It could additionally clarify default resolution or project_id semantics, but these are either schema-provided or not essential to 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 high at 83%, but the description adds value beyond the schema by explaining when to use each model, what the model names mean, the 14-reference limit, and the GPT 2K resolution restriction. This supplements the enum descriptions with practical decision-making context.

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: 'Generates an AI image,' which makes the core function immediately identifiable. It also clarifies scope by listing concrete outputs and referencing siblings like get_pricing, distinguishing this tool from video/sheet 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 gives explicit model-selection guidance with conditions for each variant, plus a note to consult get_pricing for credit costs. However, it does not state when to choose generate_image over sibling tools like generate_sheet or generate_video, so the exclusion guidance is incomplete.

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 minimal annotations, the description discloses that the operation costs credits, that dry_run quotes without charging, that the tool enforces grid/cut-clean guarantees and omits lines/labels, and what the return payload contains (generation, plan, sequences, prompt). This is substantial behavioral context for an agent deciding whether invocation is safe and appropriate.

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 densely packed with non-redundant guidance: a front-loaded outcome statement, clearly separated sections for costs, job routing, and returns, and bullet lists that are scannable. No sentence is filler; each contributes either semantics, guardrails, or workflow direction.

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

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

For a complex 15-parameter tool with no output schema, the description covers the core workflow, parameter selection by job, cost behavior, and follow-up with get_sheet_atlas. It does not explicitly route the agent to plan_sheet as the planning alternative, so an agent might be unsure whether planning belongs here or elsewhere, but this is a minor gap given the overall richness.

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 93%, so the schema already documents most parameters; the description adds extra value by clarifying which parameters belong to which kind (e.g., art_style for frames only, no art_style for sprites, items for icons/stickers/props), explaining the default for sequences (smooth = in-between after every drawing), and warning that subject is required to prevent invented subjects.

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 precise specification — "Makes ONE image holding several separate elements laid out so each can be cut out" — and enumerates concrete outputs (animation cycle, sprite sheet, icon set, stickers, props). It explicitly distinguishes itself from generate_image by saying to never call generate_image for a sheet, which removes ambiguity 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?

It provides explicit routing by job type: animation uses kind frames + sequences + subject + art_style, pixel-art uses kind sprites + sequences with no art_style, and icon sets use kind + items. It also tells the agent to quote with dry_run:true first and to use get_sheet_atlas afterward, giving clear when-to-use and 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 only say readOnlyHint=false and destructiveHint=false, so the description carries the burden of behavioral disclosure. It clearly states this is the MOST EXPENSIVE operation, priced per second, charged on completion, using purchased credits only, and async via poll get_video. It also discloses the promotion discount and instructs the agent to quote from dry_run rather than the guide. This is rich, decision-relevant behavioral context.

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

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

The description is dense and front-loaded with the most critical facts (cost, async, dry_run). It uses compact bullet-like lines and abbreviations to pack a lot of model-specific guidance into a small space. It loses one point because the pricing table is complex and somewhat hard to parse at a glance, but every sentence earns its place and there is 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?

For a 12-parameter, high-cost, async generation tool with no output schema, the description is remarkably complete. It covers cost model, billing timing, async polling, quoting flow, model selection per job, duration ranges, reference clip semantics, and the promotion. An agent has enough context to invoke the tool correctly and to ask the user for confirmation before spending credits.

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 92%, so the schema already documents most parameters well. The description adds meaningful semantics beyond the schema: it explains how reference_video_id behaves differently per model, how reference_image_ids counts differ per model, what duration defaults apply per model, and how mode maps to resolution tiers. It doesn't exhaustively restate every parameter, but it adds the cross-model constraints that the schema alone cannot express.

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 ('Makes a video from an image the user owns') and immediately distinguishes the tool from siblings like generate_image and get_video. It also names the model families and their distinct jobs, so an agent can tell exactly what this tool produces and how it differs from related 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 explicit when-to-use guidance: it explains the default model, when to choose each alternative (e.g., 'Cheapest clip WITH sound', 'Keep an existing clip's acting', 'Copy a dance or gesture'), and even instructs to quote with dry_run:true and confirm the number with the user. This is far beyond a minimal usage note and directly routes the agent to the correct model per job.

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, so the read-only nature is already known. The description adds 'Fetches metadata' which is consistent but does not disclose additional behavioral traits such as error handling, pagination, or what happens when the asset_id is invalid. With annotations covering the safety profile, the description meets a baseline but offers no extra insight.

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 wasted words. It front-loads the action and resource, making it immediately readable. It is an example of efficient specification.

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 and only one parameter, the description is still incomplete. It fails to indicate what 'metadata' includes or the structure of the response, which is critical for an agent deciding whether to call this tool. Given the many sibling get_* tools, more detail about the returned fields would be necessary for confident selection.

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 only the parameter name and type (string) with 0% description coverage. The description merely says 'by id', which adds minimal meaning beyond the schema. It does not specify the expected format (e.g., UUID, integer) or any constraints, leaving the agent to guess. The description should compensate for the missing schema descriptions but does not.

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 ('Fetches') and a clear resource ('metadata for a single asset') qualified by 'by id', which distinguishes it from siblings like list_assets (plural) and get_project/get_task (different resources). An agent can immediately understand its purpose and differentiate it from similar tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that list_assets should be used for multiple assets, nor does it clarify when get_meta or get_project might be more appropriate. The agent is left to infer usage 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 only declare readOnlyHint=true, while the description adds useful behavioral context: the call is free, and daily-cap status appears only if the token has one. This goes beyond the 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?

The description is two short sentences with no filler. The main result, the conditional nuance, and the cost implication are each given in minimal, front-loaded text.

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 zero-parameter, read-only tool with no output schema, the description states what information the agent will receive and that it is free. It does not specify the response format, but this is not critical for selecting or invoking the tool.

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

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

The tool has zero parameters and schema coverage is effectively 100%, so the description carries no parameter burden. The baseline of 4 applies because there is nothing for it to compensate for.

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 specifically identifies the resource (wallet/credits) and what is returned: the balance and, conditionally, rolling-24h daily-cap status. It is clearly distinct from siblings like get_pricing or get_storage, even though it relies on the title for the verb.

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 no explicit when-to-use guidance, no exclusions, and no comparison to alternative tools such as get_pricing or get_storage. The intended use is only implied by the title and the content described.

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 readOnlyHint=true, and the description aligns with that (no contradiction). The description adds 'generation_id' as the required identifier and notes it's 'Free', which is useful context beyond the schema. However, it does not explain what a 'cutout' is, whether URLs expire, or any rate limits. For a read-only tool, 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 concise and front-loaded with the key information: 'Fresh signed URLs for an existing cutout by generation_id. Free.' Two short sentences, no filler. It efficiently communicates the tool's function and cost.

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 schema (one required parameter) and readOnlyHint annotation, the description is fairly complete. It tells the agent what it returns (fresh signed URLs) and how to identify the cutout (generation_id). It lacks details like URL expiration or how to obtain a generation_id, but for a straightforward read operation, this is sufficient. The presence of annotations and simple schema lowers the bar.

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 has one parameter, generation_id, with no description. Schema description coverage is 0%, so the description must compensate. The description does mention that the cutout is identified by generation_id, adding some context about the parameter's purpose. However, it does not explain the format (e.g., UUID, string) or any constraints. Baseline is 3 due to zero coverage, and the description just meets that.

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 'Fresh signed URLs for an existing cutout by generation_id' clearly indicates the tool returns signed URLs for a specific cutout, using a verb (get) and a resource (cutout files). However, the term 'cutout' may not be familiar; it is likely a generated image asset. It distinguishes from siblings like get_asset or get_video by the specific 'cutout' and 'generation_id' concept.

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 fresh signed URLs for a cutout, but it does not explicitly state when to use this tool instead of alternatives like get_asset or get_detections. It does not mention prerequisites (e.g., generation_id from a prior generation) or conditions where it should not be used.

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 only declare readOnlyHint true, so the description correctly adds behavioral details: it lists the output types, notes that it is free, and explains the 404 error meaning 'never scanned' with a recommended follow-up. This goes well beyond the annotation coverage, making the tool's behavior transparent.

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 compact—three sentences that each add value: the output content, the usage purpose, and the error handling. There is no fluff or redundant phrasing, and the most important 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?

For a read-only tool with two parameters and no output schema, the description is complete. It covers what the tool returns, how to interpret an error, and what to do before using it, ensuring an agent can call it correctly without further 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 schema documents both parameters fully (target_id as 'Generation or asset id' and target_type with enum and default). The description does not add any additional parameter semantics, so the baseline score of 3 is appropriate given 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 states exactly what the tool returns—item names, categories, textures, colors, and bounding boxes (0-1000 normalized) plus a scene narrative. It clearly differentiates itself from scan_image (a prerequisite) and explicitly connects to restyle by mentioning picking item names, making its 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?

Provides explicit usage context: use it to see image contents or to pick item names for restyle, and instructs to run scan_image first if a 404 is encountered. It does not explicitly mention 'when not to use' or name alternative tools like get_meta, but the guidance is clear and actionable.

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, so the safe-read behavior is covered. The description adds useful context by listing return facets and noting the operation is 'Free', but it does not explain any limits, output structure, or why sheet.asset_id should be preferred.

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 short and contains no filler; every fragment adds information. It is telegraphic to the point of being cryptic, but each item (entity scope, facets, ref preference, cost) 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 one-parameter read-only tool this is mostly adequate: it names the return facets and gives an id preference. Still, without an output schema, the description leaves ambiguity about the exact return format, what refs are accepted, and whether sheet.asset_id is required or merely preferred.

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 has zero description coverage for the single id parameter, so the description carries the full burden. 'Prefer sheet.asset_id as a ref' is a valuable, concrete hint about what kind of identifier to pass, partially compensating for the otherwise bare string type.

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 ('One character, prop or place') plus description ('One entity: refs, sheet, looks, links, facets, bio, voice') makes clear this retrieves a single entity of a certain type and lists the data facets it returns. However, it never states the action explicitly and does not distinguish itself from sibling tools like get_asset or list_entities.

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

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

The only usage hint is 'prefer sheet.asset_id as a ref', which addresses how to form the id parameter but not when to choose this tool over alternatives. No context is given for when get_entity is appropriate versus list_entities or get_asset.

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 the description adds 'Free, no side effects' which reinforces the safety profile. It doesn't add much beyond the annotation, but the explicit 'no side effects' is a small value-add.

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 short sentences with zero waste. The core purpose is front-loaded, and the safety note is a single clause.

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 zero-parameter, read-only capability check, the description is complete. It doesn't describe the return format, but with no output schema and a simple capability-flag response, this is a minor 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 0 parameters, so the schema is trivially complete. The description doesn't need to explain parameters, and the baseline for 0 params is 4.

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 ('Check') and resource ('server capabilities'), and the title reinforces it. It clearly distinguishes itself from sibling tools like get_credits, get_storage, and whoami by focusing on version + capability flags for feature detection.

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

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

The description implies usage for feature detection ('for feature detection'), which gives clear context. It doesn't explicitly name alternatives or exclusions, but the context is sufficient for an agent to know when to call 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 provide readOnlyHint=true, so the description needn't restate that. It goes beyond by specifying the pricing model details (per-second video rows, fixed Veo naming) and that it's free, which adds behavioral context that the annotations don't cover. It doesn't disclose return format, but for a zero-param read-only price lookup, the safety and cost implications are well handled.

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?

Dense, information-packed description with no filler. It front-loads the core purpose, then lists covered items, then adds the free and alternative-usage notes. Every sentence earns its place, and the structure is easy to scan.

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 zero-param read-only price lookups tool, the description covers all an agent needs: what operations are priced, the naming conventions for video rows, the cost (free), and the alternative for clip-level pricing. No output schema or params to compensate for, so completeness is high.

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 100% (nothing to cover). The description's detailed enumeration of the pricing dimensions (model tiers, video row patterns) substitutes for parameter documentation by telling the agent what to look for in the output. This is high value given there's no schema to lean on.

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?

States a specific verb ('get') and resource ('pricing'), and enumerates exactly what it covers: image tiers per model, restyle, cutouts, scans, and video rows. It clearly distinguishes itself from sibling tools like get_credits (a different concept) by specifying it's the live credit cost of every operation.

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

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

Explicitly says it's free, and provides a conditional alternative: for a whole clip's price, use generate_video with dry_run. This gives clear when-to-use and when-not-to-use guidance, and names the alternative tool, which is exactly what an agent needs to route correctly.

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, so the description does not need to restate safety. It adds no extra behavioral context (e.g., absence handling, return payload). The description 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 compact sentence with no fluff. 'Fetches a single project by id' is front-loaded and delivers the essential information efficiently.

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

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

For a simple read-only getter with one parameter and no output schema, the description is functional but sparse. It does not mention possible error behavior or return format, which an agent might need. However, the simplicity mitigates some incompleteness.

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%, so the description must carry meaning for the parameter. It does clarify that 'project_id' is the identifier used to fetch the project, which is minimal but adequate for a single parameter. However, it lacks format or constraints beyond that.

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 ('Fetches') and resource ('a single project by id'), making the tool's purpose clear. It distinguishes from list-oriented siblings implicitly, but does not explicitly name any alternative.

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_projects or resolve_project. The description does not mention any exclusions or context that would help an agent decide between 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 include readOnlyHint=true, and the description adds context: it's FREE, returns Aseprite JSON with specific fields, and is for sheets you own. This complements the read-only nature without contradiction, but doesn't detail any potential limitations or side effects (which are minimal for a getter).

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 redundant words. The purpose is front-loaded ('FREE' and the data returned), and the 'instead of' clause adds value 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?

With no output schema, the description adequately covers the return format (Aseprite JSON) and its contents. It doesn't mention error scenarios or pagination, but for a single-parameter getter this 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?

Schema description coverage is 0%, so the description's clarification that generation_id is 'for a sheet you own' is essential. It gives meaning to the only parameter, though it doesn't elaborate on format or validation rules.

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 returns specific data (frame rects, registration, fps, pivot, animation tag) in a specific format (Aseprite JSON) for a sheet the user owns. It distinguishes itself from sibling tools like plan_sheet or get_asset by its specialized 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?

It provides a clear condition ('For a sheet you own (its generation id)') and a hint to use it instead of measuring gutters. However, it doesn't explicitly name alternative tools or state when not to use it, leaving some inference to the agent.

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 readOnlyHint annotation already signals a safe read operation. The description adds only 'Free', which is a billing note, not behavioral context about return format, rate limits, or authentication. It does not describe what the tool actually returns or any side effects, so it adds minimal value beyond the annotation.

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

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

The description is very short and concise, but it is not well-structured—it consists of two fragments rather than a clear sentence. It front-loads 'Storage usage and quota' before 'Free', which is reasonable, but the lack of a verb makes it feel incomplete. It earns a middle score because it is concise but lacks proper sentence structure.

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?

There is no output schema, so the description must explain what the tool returns. It vaguely says 'Storage usage and quota' but does not specify the format, units, or whether it returns both usage and limit. It also does not indicate that it refers to the current user's storage, which could be ambiguous. Given the minimal context, an agent would not know what to expect in the response, making this incomplete.

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%. With no parameters to explain, the description does not need to add parameter details. The baseline of 4 is appropriate since there is nothing to document.

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 is a fragment ('Storage usage and quota. Free.') rather than a clear verb-resource statement. It implies the tool reports storage usage and quota, but it never explicitly says 'get' or 'retrieve'. The title 'Check storage usage' is clearer, but the description itself is vague. It does distinguish from sibling tools by naming the storage resource, but lacks a specific action verb.

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. It does not mention whether to prefer it over get_credits, get_pricing, or other account-related getters, nor does it state any conditions or context. The only extra note is 'Free', which is a cost attribute, not a 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?

Annotations already provide readOnlyHint=true, so the safety profile is covered. The description adds the polling use case, but does not disclose response format, error behavior, or what 'status' contains. Since the annotation lowers the bar, the added context earns a 3 rather than lower.

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, both informative and front-loaded with the core action ('Status of a single task by id'). No filler or redundant phrasing; 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 read-only tool with one parameter and a readOnlyHint annotation, the description is nearly complete. It implies the response is the task's status, but does not describe the response structure or error handling. Given the simplicity, this is a minor gap rather than a critical omission.

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 must compensate for the parameter meaning. It states 'by id', which clarifies that task_id is the identifier of the task, but adds little beyond the parameter name itself. For a single self-explanatory parameter, this is adequate though minimal.

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 ('get status') and resource ('task') with a clear identifier ('by id'), distinguishing it from siblings like list_tasks (plural) and cancel_task/retry_task (different actions). The addition of 'Use to poll long-running operations' further clarifies its intended 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 gives a clear context for when to use this tool: 'Use to poll long-running operations.' However, it does not explicitly mention alternatives or exclusions, such as when to use list_tasks or cancel_task instead, so it stops short of full 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 readOnlyHint annotation, the description reveals that the tool is a polling endpoint, that completion returns signed URLs, that it is free with credits settling on completion, and gives per-model time estimates. This is meaningful behavioral context, though it doesn't cover edge cases like invalid task_id or URL expiry.

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 compact sentences front-load the core purpose, then add polling guidance, result contents, cost behavior, and timing expectations. No filler 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?

For a one-parameter read-only poller with no output schema, the description covers purpose, polling cadence, return values on completion, and cost behavior. It omits failure response details, but the mention of 'completed/failed' gives the agent enough to infer status handling.

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 schema description coverage at 0%, the description compensates by defining task_id as the identifier returned from generate_video. It clarifies the parameter's origin and role, which is sufficient for a single required string 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 opens with 'Status of a video job by task_id (from generate_video)', which pairs a specific verb/resource and identifies the originating tool. It distinguishes itself from generic task/asset getters by naming the return of signed video_url and preview_url.

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 frames usage as a poller after generate_video and gives a concrete poll interval ('every ~15-30s') and stop condition ('until completed/failed'). It doesn't explicitly mention alternative tools like get_task or when not to use it, so it stops one point short.

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, the description adds a meaningful behavioral consequence: 'Counts against storage.' It also clarifies that no AI processing occurs, which is a non-obvious behavioral trait. The write nature is implied by 'imports' and consistent with the annotations, so there is no 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?

The description is a single sentence that packs the essential facts—remote URL import, project timeline destination, no AI, and storage cost—without redundant wording. It is front-loaded with the core 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 import operation, the description covers the core semantics and storage impact, but it omits any mention of return values, error handling, or the meaning of the optional name parameter. Since there is no output schema, some expectation-setting about the result 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It partially explains 'url' via 'remote image (by url)' and 'project_id' via 'into a project timeline,' but the optional 'name' parameter is entirely unexplained, leaving a meaningful gap for an agent.

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 action (imports), the resource type (remote image by url), and the destination (project timeline), while explicitly noting 'no AI' to distinguish it from generation tools. This makes it immediately distinguishable from siblings like upload_asset and generate_image.

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 'remote image (by url)' gives clear usage context: this tool is for importing existing remote images, not for generating or uploading local files. It does not explicitly name alternatives like upload_asset, but the operative context is clear enough for an agent to select it correctly.

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 readOnlyHint annotation already establishes that this is a safe read operation, and 'Lists' is consistent with that. The description adds the asset scope (uploads + references), but provides no additional behavioral context such as pagination behavior, ordering, or authentication needs.

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 verb and resource. Every word contributes meaning, and there is no redundant restating of the tool name or title.

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 list tool, the description is minimally adequate: it names the resource and implies a returned collection. However, it omits pagination semantics, category filtering details, and any guidance on how this list relates to the many sibling list tools.

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

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

Schema description coverage is 0%, so the description needed to compensate, but it does not mention limit, offset, or category at all. The parameter names are weakly self-explanatory but their semantics, allowed values, and effects are left entirely to inference.

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 ('Lists'), a clear resource ('the user's assets'), and the scope ('uploads + references'). This distinguishes it from sibling list tools like list_favorites, list_generations, and list_tasks without needing to inspect schemas.

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 no guidance about when to use this tool versus alternatives such as get_asset, upload_asset, or search. It does not state exclusions, prerequisites, or conditions that would route an agent to a sibling 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 establish readOnlyHint=true, so the safety profile is covered. The description adds two behavioral details beyond annotations: returned ref ids can be fed to generate_video, and the operation is 'Free' (no credit cost). It does not address output shape or pagination, but for a read-only list with annotation coverage, this is adequate, 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 short, but brevity comes at the cost of substance: the main phrase duplicates the title and leaves no room for purpose or parameter detail. It is under-specified rather than efficiently 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 1-parameter read-only list without an output schema, the description is minimally serviceable but fails to fully situate the call: it omits what the response contains (beyond id semantics), how kind filters results, and how this differs from sibling list tools. The generate_video reference hint is useful, but it is one dangling detail rather than a complete picture.

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 needed to compensate by explaining the kind parameter, but it never names kind. 'Characters, props, places' maps loosely to three of the four enum values and omits 'look', and it offers no definitions or guidance for choosing a value.

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

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

The description's primary clause 'Characters, props, places' exactly restates the tool title and leaves the verb implicit; an agent must infer 'list' from the tool name. The added phrase about ref ids is data semantics, not a statement of purpose, and it does not distinguish this listing tool from siblings like list_assets or list_generations.

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 when-to-use guidance or comparison to alternatives is given. 'ref ids are generate_video reference_image_ids' hints at a downstream use in generate_video, but it does not say when to prefer list_entities over list_assets, get_entity, or other siblings. The word 'Free' vaguely signals cost, but not usage conditions.

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, so the safety profile is covered. The description adds useful behavioral context beyond that: results are ordered newest first and each item includes an image_url. It does not describe pagination or empty-result behavior, but that is a minor gap for a simple read-only list tool.

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

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

The description is compact, front-loaded, and every sentence earns its place: what is listed, how it is ordered, what the items contain, and when to use it. No redundant filler exists.

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 list tool with three self-explanatory parameters and readOnly annotations, the description covers the core purpose, ordering, and a key output field. It is slightly incomplete because limit/offset are not described, but the overall context is sufficient for most agents to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only hints at project_id via 'in a project' and never explains limit or offset, even though their semantics are not formally defined anywhere. The parameter names are conventional, but the description does not add the needed 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 uses a specific verb ('Lists'), identifies the exact resource ('FAVORITED (hearted) photos in a project'), and adds distinguishing detail ('newest first'). It clearly separates this tool from siblings like list_assets, list_generations, and list_projects by emphasizing the favorited/liked subset.

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 states a clear use case: 'Use this to look at a project's best/liked shots.' This tells an agent when to choose it, though it does not explicitly mention 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.

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

Annotations already declare readOnlyHint=true, covering safety. The description adds the ordering behavior 'newest first', which is beyond annotations and useful for callers. 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 sentence, front-loaded with the action and scope, and contains no filler or redundant information.

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

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

The tool is a simple list operation, but the description omits parameter details (limit/offset) and the title says 'photos' while the description says 'generations', creating a slight mismatch. With no output schema, the return structure is also unspecified, leaving moderate 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 0% and the description does not mention any parameter semantics. With three parameters (limit, offset, project_id) and zero compensation from the description, an agent cannot infer how to use them correctly.

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

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

The description clearly states the verb 'Lists', the resource 'generations', and the scope 'in a project', plus ordering 'newest first'. This distinguishes it from sibling tools like list_projects and list_assets, making the purpose unambiguous.

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

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

The description provides clear context that this tool lists generations within a project, implying when to use it. However, it does not explicitly mention alternatives or exclusion conditions, so it falls short of the highest bar.

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 readOnlyHint annotation already communicates that this is a safe read operation. The description adds the ordering behavior, but does not disclose pagination behavior, return format, or any other operational details. With annotations present, 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, front-loaded sentence with no filler. Every word adds meaning, and the most important scoping information ('the user's projects') comes first.

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 is sufficient for a simple read-only list operation, but it leaves the pagination parameters undocumented and provides no output expectations. Given the low schema description coverage and missing output schema, more detail 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?

Schema description coverage is 0%, so the description must compensate for the undocumented limit and offset parameters. It does not mention pagination at all, though the parameter names are conventional enough that an agent may infer their 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?

States a specific verb ('Lists'), a clear resource ('the user's projects'), and a sorting behavior ('most-recently-updated first'). This clearly distinguishes it from sibling tools like list_assets or list_generations.

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 get_project, resolve_project, or other list tools. The intended context is implied by the name and description, but no alternatives or exclusions 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 readOnlyHint annotation already declares this as a safe read operation. The description adds useful context about which task types are included, but it does not disclose behaviors like status filtering, pagination, ordering, or whether all users' tasks are returned. With annotations covering safety, a mid score is appropriate.

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 and front-loaded with the verb and resource, and the examples are informative without being verbose. It earns its place by clarifying what counts as a background task. No redundant content.

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 and two undocumented parameters, the description does not explain what the returned task objects look like, how status filtering works, or how limit behaves. It is adequate for a trivial read-only list, but the missing parameter and return-value context leaves gaps 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 0% and the description is silent about the 'limit' and 'status' parameters. Since there is no parameter documentation in the schema either, the agent receives no explanation of acceptable status values or how limit affects results. The description adds no meaning beyond the parameter names themselves.

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

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

The description clearly states the verb 'Lists' and the resource 'background tasks', and gives concrete examples (generations, uploads, scans, exports). It is distinct enough from siblings like get_task or cancel_task, though it does not explicitly contrast with list_generations or list_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 provides no guidance on when to use this tool versus alternatives such as list_generations or list_assets. It simply states what it lists, leaving the agent to infer usage context from sibling 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 provide readOnlyHint=true, and the description adds complementary behavioral context: it is FREE, prompt-only, does not generate images itself, and returns a downstream-ready prompt. There is no contradiction, and the added cost and side-effect note goes beyond what annotations state.

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

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

Three short sentences, each earning its place: free/cost signal, core behavior, and routing to the preferred alternative. Key information is front-loaded and there is no filler or repetition.

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

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

For a planning tool with 100% schema coverage and readOnlyHint, the description sufficiently describes what is returned ('the plan and the exact prompt') and how to consume it elsewhere. It could say a bit more about the shape of the plan, but the description is adequate for an agent to select and call it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents the 10 parameters. The description adds only a high-level statement that plan_sheet 'takes what generate_sheet takes' and mentions output parameters like prompt and aspect_ratio, but it does not need to compensate for schema gaps because the schema already carries that burden.

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: it 'returns the plan and the exact prompt' for sheets, and positions itself as the 'prompt-only door'. It explicitly contrasts with generate_sheet and generate_image, so an agent can distinguish it from the closest 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?

The description gives explicit usage direction: use plan_sheet only to generate elsewhere with generate_image, and 'prefer generate_sheet' for the normal path because it 'keeps the prompt server-side and quotes with dry_run'. This directly answers when to use this tool versus 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 already declare idempotentHint=true and destructiveHint=false. The description adds 'free' (cost info) and 'case-insensitive' matching, which are not in the annotations. It also discloses the potential create side-effect. This adds value beyond the structured fields, though it doesn't cover error handling or return format 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?

Two sentences with no fluff. The core purpose is front-loaded, followed by the usage convention and expected output. Every 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?

For a single-parameter, no-output-schema tool, the description is sufficient. It mentions the returned project_id, the convention, and the idempotency/free nature. Nothing an agent needs to invoke it correctly 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% for the single 'name' parameter, but the description enriches it with the matching rule: 'exact name (case-insensitive)'. This goes beyond the schema's '1-100 chars' description and helps the agent understand how the parameter is used.

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 (finds or creates) and resource (a project by name), and distinguishes itself from siblings like create_project and get_project by describing the find-or-create behavior. It also adds the case-insensitivity detail, making the 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 explicitly instructs when to use this tool: 'Use this to follow the one-project-per-folder convention: resolve the folder's name, then pass the returned project_id to other tools.' This gives a concrete workflow and implies the alternative (using get_project when you already have an ID) without needing to state 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?

Discloses costs credits, always creates a new generation, original untouched, and explains behavior of merge_bias and style_intensity. These add value beyond the annotations (readOnlyHint false, destructiveHint false) by giving specific cost and non-destructive details. No 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?

The description is dense but well-structured: starts with core purpose, then cost, then mode breakdown. Each sentence carries info; no filler. Slightly long but appropriate 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?

For a 12-parameter tool with no output schema, it covers costs, modes, parameter interactions, and reference semantics. It does not explain resolution or aspect_ratio beyond schema, but those are self-explanatory. It's nearly complete 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?

Schema coverage is 83%, but the description enriches meaning for many parameters: explains action modes, how reference_id works, merge_bias scale, style_intensity scale, and when to use get_detections. This goes well beyond the schema descriptions.

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

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

The description states a specific verb ('edits') and resource ('existing image'), and distinguishes from siblings like expand_image or cutout by focusing on AI-driven restyling. However, it does not explicitly name alternatives, so it's not a 5.

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

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

Extensive guidance: lists modes, tells when to use get_detections for item names, explains merge_bias and style_intensity, and clarifies that reference_id can be an asset or generation. It clearly tells an agent how to choose the right action and what parameters to set.

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 reveal the operation is mutating and non-destructive, but the description adds no context beyond that, such as whether retrying reuses original inputs, re-queues the task, or may consume credits. The description does not contradict the annotations, but it also provides no behavioral detail.

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 single sentence is concise and front-loaded, but it is also underspecified: it essentially restates the title and leaves meaningful behavioral and parameter guidance out. This is brevity rather than efficient completeness.

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 task-lifecycle mutation with no output schema, the description does not state what a successful retry returns, what state transitions occur, or whether retry is only valid after failure. It is too thin to fully support 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?

With 0% schema description coverage, the description needed to explain task_id, but it only implies that the ID identifies the failed task. There is no explicit statement that task_id is the failed task's identifier or any detail about where to obtain it.

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 names a specific action, 'retries', and a specific resource, 'a failed task'. It is clear enough to distinguish from read-only task operations like get_task/list_tasks and from cancel_task, though it does not explicitly name a 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?

There is no guidance on when to retry versus cancel or inspect a task, no mention of prerequisites such as the task needing to be in a failed state, and no discussion of alternatives. The phrase 'failed task' implies a condition but nothing explicit.

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 (readOnlyHint=false, destructiveHint=false), the description reveals that the tool costs credits, takes 5-20 seconds, and returns synchronously when done. It also discloses that results are consumed by search and get_detections, giving the agent a clear picture of side effects and resource 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 two compact sentences with zero filler. The core purpose is front-loaded, followed by cost, latency, and a strong 'usually unnecessary' caveat. Every clause adds actionable information.

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

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

For a tool with only two parameters and no output schema, the description covers the essentials: what it does, cost, latency, and when to avoid it. It does not specify what the return value looks like (e.g., a task ID), but given the presence of sibling tools like get_task, this omission is minor.

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 target_id and target_type already described. The description merely restates 'generation or asset' without adding new format or usage details, so it does not elevate the parameter understanding beyond what the schema already 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 'runs the detection scan' on a generation or asset, and enumerates the detection types (items, colors, textures, scene). It distinguishes itself from retrieval tools like get_detections by focusing on the action of scanning rather than reading results.

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 'Usually unnecessary' because scans happen automatically, which tells the agent not to use it by default. It also notes that results power search and get_detections, implying those are the downstream consumers, though it stops short of naming when exactly to force a scan (e.g., after a failed scan).

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 readOnlyHint annotation covers safety, and the description adds substantial behavioral context beyond that: results can include matches inside videos with an exact video_moment timestamp, and each image_url is only a 600px preview rather than the full original. This materially changes how an agent should use the returned data.

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 well structured: core capability first, then mode definitions, then scoping/filtering, then special result behaviors, then a caveat with an alternative tool. Every sentence adds operational value, and the length is justified by the tool's 15 parameters and lack of an output schema.

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

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

For a complex search tool with no output schema, the description covers the critical gaps: mode interactions, required versus optional inputs, result shapes like video_moment and regions, preview limitations, and the pointer to list_generations for full-fidelity originals. Remaining details like limit and offset are already present in the 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 already high at 87%, so the description does not need to re-document parameters. It adds value by explaining mode-dependent semantics such as query being required for text mode, similar modes requiring anchors, and include_regions producing bounding-box data, plus the video_moment consequence of certain text results.

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: detection-aware search across the user's assets and generations. It distinguishes itself from title/prompt-based retrieval and from sibling listing tools by emphasizing what the scanner SAW inside each image, and it breaks out four distinct modes so an agent immediately understands the tool's 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?

It gives mode-specific usage rules: text requires a query, color ranks by hex closeness, similar needs an anchor, and browse requires no query and is for exploration. It also instructs when to step outside this tool, telling the agent to re-read the original from list_generations before using a hit in a document.

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 readOnlyHint already flagging a safe read operation, the description adds useful behavioral context: 'FREE' signals cost behavior, and it discloses mode-dependent response content (index vs full frame lists). It does not mention rate limits or auth, but for a read-only menu tool with this annotation, the additional context is sufficient.

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 economical; every sentence adds either domain context or call behavior. The leading 'FREE' and core purpose are front-loaded, and the rest of the content explains invocation modes without filler. The first sentence is a long enumeration, but it remains readable and purposeful.

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 carries the burden of explaining return values, and it does: no arguments yields the index, while family+type yields full frame lists. It also mentions frame counts per detail level and resolution ceilings, which are the key data points an agent would need. It is complete enough for a read-only menu tool.

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

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

The schema already documents both parameters, so the baseline is 3. The description goes beyond by explaining the no-argument case, the family+type combination, and the relationship to generate_sheet. This adds practical meaning to the parameters rather than just repeating schema names.

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 resource as the menus/options a sheet is made from: kinds, keyable grounds, art styles, animation sequences, levels, and image models. It also differentiates from generate_sheet by stating 'The ids go straight into generate_sheet.' It lacks an explicit verb like 'returns' or 'lists,' but the behavioral intent is unambiguous from 'No arguments = the index, ids and one-liners.'

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 specifies two calling modes: no arguments returns the index, and family + type returns that type's sequences with full frame lists. This tells the agent exactly when to call with parameters versus empty. It names generate_sheet as the downstream consumer but does not explicitly discuss when not to use this tool 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?

The annotations already indicate readOnlyHint=false and destructiveHint=false inferring mutation without destruction. The description adds useful nuance: the asset is stored, can be associated with a project's product photos, and may be invisible to projects without project_id. But it does not mention URL accessibility, authentication, or effects on existing assets.

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 purposeful sentences with no filler. The main action comes first, the return value second, and the conditional usage guidance last. The last sentence is dense but contains necessary behavioral detail rather than vague prose.

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 return value and one important conditional workflow, and the annotations already carry the mutation-safety signal. But it is incomplete for a 4-parameter tool: name is undefined, other category values are unspecified, and there is no output schema or return type detail beyond 'asset id'.

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

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

Schema description coverage is 0%, so the description must do the work. It clarifies that url means a remote image URL and explains the interplay of category='product' and project_id in a specific case. However, the name parameter is completely undocumentedaine, and category semantics are only shown for one value, leaving the agent to infer other valid inputs.

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 identifies the action ('Uploads a remote image by url'), the object ('as a reusable reference asset'), and the result ('Returns the new asset id'). It is clear and concrete, but it does not explicitly distinguish itself from the similarly named sibling tool import_image, so it misses full 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?

It provides actionable guidance for the product-category + project_id case and explains the behavior without project_id. However, it never states when to prefer this tool over import_image or other asset operations, and it does not mention any exclusions or 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 annotations only indicate readOnlyHint=false and destructiveHint=false, so the description carries the responsibility for behavior. It adds important behavioral detail beyond the annotations: the operation costs credits, is billed at the target resolution, and produces a new generation rather than modifying the source. It does not mention whether the operation is asynchronous or what the return shape is.

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 short sentences with no filler. The core action is front-loaded, the critical cost warning is visibly flagged, and the creation semantics are stated last 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?

For a simple two-parameter tool with no output schema, the description covers the essential operational context: what it operates on, what it produces, where the result goes, and that it has a credit cost. The only notable gap is the lack of explicit return/async behavior, which could matter when chaining calls.

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 schema coverage at 50%, the description compensates for the undocumented generation_id by tying it to an 'existing generation' and clarifying the project scoping. It reinforces resolution as the target/driver of cost, and the schema's enum covers the concrete values.

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 identifies a specific operation—re-rendering an existing generation at a higher resolution—and clarifies that it creates a NEW generation within the source project. This distinguishes it from sibling generation and image-edit tools like generate_image, restyle, or expand_image, even without naming 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?

It clearly implies when to use the tool: for an existing generation that needs higher resolution. It does not explicitly name alternatives or exclusion criteria, but the 'existing generation' and 'source's own project' context provides clear handling 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?

The readOnlyHint annotation already signals a safe read, and the description adds the useful behavioral detail that the call is 'Free', meaning it does not consume credits. It also clarifies the data scope: authenticated user, plan, and credit balance. It does not contradict the annotation.

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 minimal and front-loaded: it states the resource and data fields in one brief sentence and adds the cost detail 'Free' as a second short sentence. There is no wasted 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?

For a zero-parameter read-only lookup, the description provides sufficient context: who the data is about, what fields are returned, and that it is free. The only minor gap is not describing the response format or error behavior, but this is acceptable given the simplicity of the tool and the presence of the readOnlyHint annotation.

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 zero parameters cardinality=0, the description carries no parameter burdenressing baseline 4. Schema coverage is trivially complete, and the description adds context about what the returned information represents.

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 returning the authenticated user, plan, and credit balance. It is a resource-scoped info lookup, though it lacks an explicit verb such as 'retrieves' or 'returns'. The title reinforces the purpose, and the description is distinct enough from sibling tools like get_credits.

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 such as get_credits. The description implies it is for current account context, but it does not state exclusions or direct the agent toward a sibling for more specific needs.

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