NativeAds

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

Annotations already indicate idempotentHint=true and destructiveHint=false. The description adds value by explaining that activating an already-active version 'succeeds with no change', which clarifies the idempotent behavior beyond just the hint. No other behavioral aspects are omitted, and no contradiction exists.

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

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

The description is extremely concise: two sentences, no filler. The first sentence states the purpose and effect, the second clarifies idempotency. 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?

Given the tool's simplicity, the comprehensive schema coverage, and the annotations, the description is complete. It explains the action, the impact on generation, and the idempotent behavior. No additional details (e.g., return value) are necessary for such a straightforward mutation.

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

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

The input schema provides 100% coverage with descriptions for both parameters (brandId and versionId). The description does not add any additional meaning or constraints beyond what the schema already conveys, so the baseline score of 3 applies.

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

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

The description clearly states the verb ('Make a Brand DNA version the active one') and the resource ('for its brand'), and explains the consequence ('so useBrandDna applies it in generation'). This distinguishes it from sibling tools like delete, patch, or cancel, which perform different operations.

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

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

The description implies the tool should be used when you need to set a specific version as active, but it does not provide explicit guidance on when not to use it or mention any alternatives (e.g., patch might also affect activation state, but no clarification is given).

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 idempotentHint=true and destructiveHint=false. Description adds context that no committed asset is affected, reinforcing safety and clarifying the scope of cancellation.

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

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

Two concise sentences, no filler, front-loaded with action and key constraint. Every word adds value.

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

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

For a simple tool with one parameter and no output schema, the description explains effect, idempotency, and lack of side effects, making it fully actionable.

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

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

Only one parameter with 100% schema coverage; the schema already notes it's from initiate_asset_upload, so the description adds no additional semantic value beyond the schema.

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

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

Explicitly states the action (cancel), target (in-progress asset upload), and required identifier (uploadId). Distinguishes from siblings like confirm_asset_upload and initiate_asset_upload by clarifying scope and effect.

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?

Clearly defines when to use (in-progress uploads) and implies when not to (committed assets) by stating 'No committed asset is affected'. Notes idempotency, but does not explicitly list alternatives.

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

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

The description adds context beyond annotations: it clarifies that committed versions are unaffected and states idempotency. It does not contradict annotations (idempotentHint=true, destructiveHint=false). No mention of side effects or auth, but sufficient for a simple cancellation.

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

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

Two concise sentences with no filler. Front-loaded with the key action and distinctions. Every sentence adds value.

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

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

For a simple idempotent cancellation with two required params and no output schema, the description is sufficient. It covers the key behavioral aspects. Could mention error handling (e.g., if version already cancelled) but overall complete.

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

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

Schema coverage is 100%, so baseline is 3. The description does not add parameter-specific meaning beyond the schema, which already describes the parameters as UUIDs. No extra guidance on how to obtain the IDs.

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

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

The description clearly states the action ('cancel'), the resource ('in-progress Brand DNA extraction'), and distinguishes it from committed versions, which differentiates it from sibling tools like delete_brand_dna_version.

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

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

The description specifies when to use (for in-progress extractions) and that committed versions are unaffected, providing clear context. It could be more explicit about not using for already cancelled or committed versions, but the guidance is adequate.

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 provide destructiveHint=false. Description adds no behavioral traits (e.g., async processing, task return). Given minimal annotations, description should disclose more but does not.

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

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

Single sentence, clear and direct. Could be improved with structured details but no fluff. Appropriate length given simplicity.

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?

No output schema; description omits processing details, return values, or side effects. For a 2-param tool, more context is needed to set expectations on what happens after confirmation.

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 50% (categoryId undocumented). Description adds no parameter info. uploadId has schema description linking to initiate_asset_upload, but categoryId lacks any guidance. Description fails to compensate for incomplete schema.

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

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

Description clearly states action 'Confirm' and resource 'completed S3 upload' and its effect 'start asset processing'. Distinguishes from sibling tools like initiate_asset_upload and cancel_asset_upload.

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?

Implies usage after upload completion but does not explicitly state prerequisites (e.g., call initiate_asset_upload first) or mention when not to use. No alternatives listed.

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

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

The description adds context beyond annotations: it explains the workflow (logo upload after creation, brand DNA later) and that descriptor fields are optional because brand DNA drives on-brand output. Annotations only indicate non-destructive, so this is valuable 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 relatively long at about 6 sentences, with some redundancy and a mix of purpose and usage instructions. While front-loaded with the main action, it could be more streamlined to improve readability.

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

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

Given the complexity (8 parameters, no output schema), the description covers workflow, parameter rationale, and user interaction steps. It lacks details on return values or error handling, but for a creation tool, it provides sufficient context for safe 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 only 13% schema coverage, the description compensates by stating that only name is required and explaining why descriptor fields are optional (brand DNA). However, it does not detail the meaning of individual parameters like tone, voice, or values, leaving gaps for an AI 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 states the tool creates a new brand in the caller's organization, with a specific verb and resource. It distinguishes from siblings like update_brand and get_brand by focusing on creation, and clarifies that only name is required, while other fields are optional.

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

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

Provides explicit guidance: when a human is present, ask for name and logo, propose industry and description, and confirm before calling. Also explains that logo upload and brand DNA application happen after this call, offering clear when-to-use instructions and steps to follow.

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 asynchronous nature, return of task ID, and activation requirement beyond what annotations provide (destructiveHint=false). No contradictions with annotations.

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

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

Two succinct sentences: first defines purpose and async, second provides critical follow-up steps. No wasted words; front-loaded with core 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 creation tool with 4 parameters and no output schema, description explains return value (task ID) and next steps (poll, activate). Lacks specification of task response format but can be inferred from get_task; adequate for context.

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

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

Schema description coverage is 75% with good schema descriptions for urls, assetIds, brandId. Description mentions 'from brand assets and/or website URLs' aligning with parameters but adds no significant new meaning beyond schema.

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

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

Description clearly states the action 'Start a new Brand DNA extraction' with the resource 'from brand assets and/or website URLs', using specific verbs and resource. It distinguishes from sibling tools like 'activate_brand_dna_version' and 'get_brand_dna_version'.

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

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

Provides clear context on asynchronous behavior ('poll get_task for completion') and required follow-up ('Activate the resulting version'). Does not explicitly mention when not to use or alternatives like 'rerun_brand_dna_version', but sufficient for typical use.

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

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

The annotation already includes 'destructiveHint: true', so the description's mention of 'destructive and not reversible' adds marginal value. It reinforces but does not significantly extend 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 uses only two short sentences that convey everything needed: the action and key behavioral traits. There is no redundant or unnecessary 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?

Given the simple destructive operation with 2 parameters and no output schema, the description adequately covers the irreversible nature. It is complete for the agent's needs.

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

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

The input schema already has 100% coverage with descriptions for both parameters ('brand UUID', 'brand DNA version UUID'). The description adds no additional parameter information.

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

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

The description clearly states the action 'delete' and the resource 'Brand DNA version', and emphasizes permanence with 'permanently delete' and 'not reversible'. This distinguishes it from siblings like 'cancel_brand_dna_version' and 'deactivate'.

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 only when permanent deletion is intended by stating it is destructive and irreversible, but it does not explicitly mention when to use it over alternatives or provide any exclusions.

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

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

The description adds behavioral context beyond the readOnlyHint annotation: it specifies the result is a presigned URL that is short-lived. Annotations already indicate read-only, so this is complementary and consistent.

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

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

Single sentence, no fluff. Front-loaded with action and key details (presigned URL, types, parameter).

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

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

Complete for a simple tool: describes return value (presigned URL), behavior (short-lived), and required parameter. No output schema needed; the description suffices.

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 description 'asset UUID'. The tool's description only adds 'by its id', which adds no new meaning. Baseline 3 applies.

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

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

The description clearly states the tool returns a short-lived presigned download URL for an asset by its ID, specifying supported types (image, video, PDF). It differentiates from sibling tools like initiate_asset_upload 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?

No guidance on when to use this tool versus alternatives. For example, when to use download_asset vs. initiate_asset_upload or other tools. The description implicitly suggests usage for downloading, but no explicit conditions or exclusions.

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

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

The description discloses key behaviors beyond annotations: asynchronous nature (returns task id), reliance on get_task, mandatory user review step, Brand DNA integration logic (use if present, offer to create if absent). No contradictions with annotations (only destructiveHint=false is present).

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 serving a distinct purpose: purpose and async nature, mandatory user review, Brand DNA handling. No redundant or superfluous text. Front-loaded with the most critical info.

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

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

The tool has 10 parameters and no output schema. The description covers the workflow well (async, user review, Brand DNA) but does not explain all parameters (e.g., duration, endFrameAssetId). Given the complexity, it is adequate but not fully comprehensive.

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 60%, so the schema already documents several parameters. The description adds value for useBrandDna (explains Brand DNA logic) and implicitly covers model default. However, it does not elaborate on other parameters like duration, endFrameAssetId, or intermediateFrameAssetIds, leaving gaps.

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

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

The description clearly states the verb (start prompt enhancement), the resource (prompt for image-to-video generation), and the context (first-frame, default model). It distinguishes itself from the sibling 'enhance_scene_forge_prompt' by specifying 'image-to-video'.

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 usage guidelines: it is asynchronous requiring polling via get_task, the enhanced prompt must be shown to the user before calling image_to_video with promptIsEnhanced=true, and explains Brand DNA handling. It lacks explicit comparison to alternatives but the context makes the tool's role clear.

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

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

The annotations provide destructiveHint=false, and the description adds critical behavioral details: asynchronous operation returning a task ID, polling via get_task, and tier-gating for explicit useBrandDna=true. This supplements the annotations without contradiction.

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

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

The description is concise with four sentences, each adding distinct value: purpose, async nature, review requirement, and Brand DNA handling. No redundant information, and key information is front-loaded.

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

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

Given the tool's complexity (6 parameters, async, tier-gated, workflow steps), the description covers essential aspects: async polling, user review step, Brand DNA behavior, and tier-gating. It could mention error scenarios or rate limits, but it is largely complete for an agent.

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

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

While schema coverage is 83%, the description adds meaning for useBrandDna (default behavior, tier-gating) and workflow context for brandId and originalPrompt. Other parameters (partner, productAssetIds) are not elaborated, but the added value raises the score above baseline.

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 'Start prompt enhancement for a Scene Forge generation,' using a specific verb and resource. It distinguishes itself from sibling tools like 'enhance_img2video_prompt' by specifically mentioning 'Scene Forge,' making its purpose unambiguous.

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

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

The description explicitly instructs to show the enhanced prompt to the user before calling scene_forge, and advises to offer creating Brand DNA if absent. However, it does not state when not to use the tool or provide explicit alternatives, slightly reducing clarity.

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

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

The description discloses asynchronicity (returns task id, poll get_task), prerequisite (parent must be completed), and resource consumption (quota). Annotations only have destructiveHint=false, so description adds significant value beyond structural fields.

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

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

Two sentences, no filler. First sentence defines purpose, second covers key behavioral details (async, prerequisite, quota). 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?

Covers essential aspects: async, prerequisite, quota. Without output schema, it directs to poll get_task. Could mention what task status indicates, but adequate for the tool complexity. Sibling get_task fills 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?

Schema coverage is 100%, so baseline is 3. Description reinforces that groupId must be completed and variationCount is 'more', but adds little beyond schema. No contradictions or extra 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 clearly states the tool adds more video variations to an existing group, reusing its recipe. The verb 'extend' and resource 'generated_videos_group' are specific, and it distinguishes from siblings like image_to_video and extend_scene_forge.

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 clear context: use after parent group is completed, and it consumes quota. It doesn't explicitly mention when not to use, but the prerequisite and resource consumption imply appropriate usage. Alternatives are implicit via sibling group.

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

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

Beyond the annotations (destructiveHint=false), the description discloses critical behavioral traits: asynchronous execution with task id, requirement that parent must be completed, and quota consumption. No contradictions with annotations.

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

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

The description is four sentences, each carrying unique information: purpose, sibling differentiation, async behavior, and prerequisites/quota. No wasted words; front-loaded with the core action.

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 input schema, no output schema, and clear annotations, the description covers purpose, usage, behavioral traits, and side effects. It could be slightly more detailed about the exact number of variations or limits, but it is sufficient for an agent to use the tool correctly.

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

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

The schema has 100% coverage for the single parameter sceneForgeId. The description does not add new parameter semantics beyond what the schema states, but it reinforces that the parent must be completed. According to the rubric, baseline is 3 when schema coverage is high.

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 'Add more image variations' and the resource 'existing Scene Forge'. It explicitly distinguishes from the sibling 'scene_forge' by saying 'Prefer this over a fresh scene_forge when you want more of the same.' This provides strong purpose clarity.

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

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

The description gives clear context on when to use this tool ('when you want more of the same') and mentions prerequisites ('parent Scene Forge must be completed') and side effects ('consumes image quota'). However, it does not explicitly state when not to use it or list all alternatives, though the key sibling is mentioned.

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

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

Annotations already provide readOnlyHint, so description's main addition is the 'active' behavioral constraint. No further disclosure about side effects or required permissions beyond read-only 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?

Single sentence with no redundant words. Clearly communicates purpose and scope.

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 tool with one parameter and no output schema, the description is complete enough. Lack of return value detail is minor since the tool's purpose is well-defined.

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 one parameter described as 'brand UUID'. Description adds no additional meaning beyond the schema, so baseline 3 is appropriate.

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

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

Description clearly states the tool fetches the active Brand DNA version detail for a brand, using specific verb and resource. It distinguishes from siblings like get_brand_dna_version (any version) and list_brand_dna_versions (list).

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 or exclusions. Agent must infer from 'active' qualifier that this is for the currently active version, while siblings exist for other version retrieval. Guidance is implied but not 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?

Annotations already declare readOnlyHint=true, and the description's 'fetch' is consistent. The description adds no new behavioral context beyond what annotations provide, which is acceptable with high annotation coverage.

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

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

The description is a single concise sentence with no unnecessary words, earning its place 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 tool with one parameter and no output schema, the description is complete and 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 100%, so the schema already documents the parameter. The description adds no additional meaning beyond the schema, warranting the baseline score.

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 'Fetch a single brand by id.' uses a specific verb (fetch), resource (single brand), and method (by id), clearly distinguishing it from siblings like list_brands.

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?

While the description implies when to use (when needing a brand by id), it does not explicitly state when not to use or name alternatives. However, the context is clear given sibling tools.

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

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

Annotations already declare readOnlyHint=true, and the description reinforces this with 'Fetch'. However, beyond that, no additional behavioral traits (e.g., pagination, response format) are disclosed.

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

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

Two concise sentences with no wasted words. The first sentence states the core functionality, and the second provides critical sibling differentiation.

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 one-parameter input and no output schema, the description adequately explains the tool's purpose and distinguishes it from a sibling. However, it could briefly mention what the payload contains or that no metadata is included.

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 the single parameter 'brandId' described as 'brand UUID'. The description adds no further parameter detail, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Fetch') and noun ('active Brand DNA payload') and explicitly distinguishes from the sibling tool 'get_active_brand_dna' by noting the latter includes metadata.

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 directly suggests an alternative tool for a more specific use case ('For the full active version with metadata, use get_active_brand_dna'), providing clear context on when to choose which 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 declare readOnlyHint=true, which the description aligns with ('Fetch'). The description adds value by stating that the result includes 'its DNA payload', providing context beyond the annotation. No behavioral 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?

Two efficient sentences with no redundancy. Every sentence adds value: first states the action, second provides usage guidance with sibling references.

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 fetch operation with two params, the description effectively communicates purpose, usage, and output content ('DNA payload'). While no output schema exists, the description hints at the return. Slightly more detail about the response structure could be added, but it's largely complete.

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

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

Schema description coverage is 100% with clear parameter descriptions ('brand UUID' and 'brand DNA version UUID'). The description adds no additional meaning beyond 'by id', which is already implied. Baseline score of 3 is appropriate.

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

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

The description uses specific verb 'Fetch' and clearly identifies the resource as 'a specific Brand DNA version's detail (including its DNA payload) by id'. It distinguishes from sibling tools by explicitly mentioning list_brand_dna_versions for ID discovery and get_active_brand_dna for active version only.

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

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

The description provides explicit guidance: use list_brand_dna_versions to find IDs, and notes that get_active_brand_dna only returns the active version, making usage context clear and differentiating from alternatives.

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

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

Annotations already declare readOnlyHint=true. The description adds context beyond the annotation by specifying what resource (usage vs cap) and scope (image+video pools, current billing period) are read.

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 clear and front-loaded, containing no unnecessary words.

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

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

For a parameterless read tool, the description provides sufficient context about the resource and scope. However, it does not describe the exact format of the response, which is acceptable given no output schema.

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

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

With 0 parameters and 100% schema coverage, baseline is 4. The description adds meaning by indicating the return value (usage vs cap), which is not present in the empty schema.

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

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

The description uses a specific verb 'Read' and clearly identifies the resource: 'caller organization's usage consumed vs plan cap (image + video pools) for the current billing period.' It distinguishes from sibling tools by focusing on feature usage, while siblings handle brand DNA, assets, etc.

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

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

No explicit guidance on when or when not to use this tool versus alternatives. The description implies usage to check consumption caps but does not mention prerequisites 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?

Annotations already declare readOnlyHint=true. Description adds that it returns enhancedPrompt once status is completed, which is useful. However, it does not describe behavior when the task is not yet completed or error scenarios.

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

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

Two concise sentences with no redundancy. Every sentence adds value: first defines the action, second provides crucial workflow guidance.

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

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

Given the tool's simplicity (2 params, read-only, no output schema), the description covers the essential flow. It lacks details on polling or error handling, but the annotations and schema cover the safety and parameter aspects sufficiently.

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 already documents both parameters with descriptions, and coverage is 100%. The description adds no new parameter information beyond what the schema provides, meeting the baseline.

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

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

Clearly states the verb (Fetch), resource (result of enhance_img2video_prompt run by id), and distinguishes from sibling tools like enhance_img2video_prompt by referencing its returned task id.

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

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

Explicitly advises to show enhancedPrompt to the user before calling image_to_video, providing context for the tool's role in the workflow. Does not explicitly state when not to use, but the guidance is clear.

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

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

Annotations already provide readOnlyHint=true, and the description adds value by specifying that the tool returns optimizedPrompt and theme only once status is completed. This goes beyond the annotation by explaining the asynchronous behavior and return conditions.

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

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

The description consists of two clear, front-loaded sentences. The first explains the core functionality, and the second provides critical workflow guidance. No redundant or irrelevant information.

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

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

Given the lack of an output schema, the description adequately explains the return values (optimizedPrompt and theme) and the status condition. It also provides essential workflow context for integration with enhance_scene_forge_prompt and scene_forge.

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

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

Schema description coverage is 100% with clear parameter descriptions for brandId and promptEnhancementId. The tool description does not add additional semantic meaning beyond restating that promptEnhancementId is obtained from enhance_scene_forge_prompt, which is already in the schema.

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

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

The description clearly states 'Fetch the result of an enhance_scene_forge_prompt run by its id', specifying the action (fetch) and resource (prompt enhancement result). It distinguishes from sibling tools like enhance_scene_forge_prompt (which creates the task) and get_img2video_prompt_enhancement (different type).

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

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

The description instructs to 'Show optimizedPrompt to the user for review before calling scene_forge', providing explicit usage context after an enhance call. It implies a sequential workflow but does not explicitly state when not to use the 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 provide readOnlyHint=true, and the description adds specific details about the returned fields (plan, subscription status, lockout mode, etc.) and confirms it is read-only. No side effects or 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?

Two concise sentences. Front-loaded with 'Call this first' and then lists key information. No unnecessary words.

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

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

For a parameterless, read-only tool with annotations, the description provides complete context: what it does, what it returns, and that it works everywhere. No 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?

No parameters, so baseline is 4. The schema already conveys no inputs; the description adds context about output, which is sufficient.

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 is a read-only orientation to be called first, and lists the specific information it returns (plan, subscription status, etc.). It differentiates from sibling tools which are specific actions like create, update, or list.

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

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

Explicitly says 'Call this first' and 'Works in any client', giving clear guidance on when to use it. It does not explicitly state when not to use it, but given its nature as a first step and no parameters, the guidance is adequate.

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 behavioral traits beyond readOnlyHint: terminal vs status word matching, succeeded meaning, retryable flag. Warns about 'completed' vs 'ready'. No contradiction with annotations.

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

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

Description is detailed but each sentence adds value. Front-loaded with primary purpose. 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?

Despite no output schema, description covers all necessary behavioral details for a polling tool: terminal, succeeded, status word, retryable, and how to get results.

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

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

Schema coverage is 100% and description adds context: 'kind' is the async tool name, 'taskId' is from async tool. Explains 'resultTool' from submit result.

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

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

Description clearly states the tool fetches async task status by task_id. It specifies the types of tasks (generation/enhancement/extraction). It distinguishes it from sibling get_*/list_* tools by noting that actual results are obtained via those 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?

Explicitly guides polling behavior: poll until terminal is true, not matching status word. Provides polling cadence suggestion. Explains status fields and retryable on failure. Directs to use result tool for actual outputs.

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

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

The description discloses the async behavior (returns task id, poll get_task) and the importance of Brand DNA, which goes beyond the minimal annotation (destructiveHint: false). However, it does not specify error conditions, rate limits, or model-specific constraints.

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

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

The description is three sentences, front-loading the core purpose and async behavior, then providing crucial usage guidance. Every sentence serves a clear role with no redundancy.

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

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

Given the complexity (12 params, async, nested objects, no output schema), the description covers the essential workflow but lacks details on model-specific capabilities, error handling, and parameter constraints such as which models support endImageAssetId. It is adequate but not fully comprehensive.

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 75% schema coverage, the description adds some value (e.g., 'startImageAssetId' suggested to be from Scene Forge, defaults for model and useBrandDna), but it fails to cover the three undocumented parameters (partner, enableAudio, promptIsEnhanced) and adds only modest context beyond the schema.

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

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

The description clearly states the action ('start a first-frame image-to-video generation'), the resource (image-to-video for a brand), and the default model. It distinguishes from sibling tools like enhance_img2video_prompt and get_task by noting the async nature and the need to poll for completion.

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 step-by-step guidance: call get_active_brand_dna first, offer to create Brand DNA if missing, and only proceed without it if the user declines. This clarifies when to use this tool versus alternatives and sets clear prerequisites.

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

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

The description discloses key behavioral traits: the tool reserves an upload, returns a presigned URL and uploadId, and requires a subsequent confirm call. The annotations only provide destructiveHint=false, so the description adds significant behavioral context beyond what annotations offer.

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

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

The description is two sentences long, front-loads the primary action, and contains no extraneous information. Every sentence is essential and contributes to understanding the tool.

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

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

The description covers the main workflow and return values (presigned URL, uploadId). It does not explain the optional categoryId or the implications of multiple files, but given the complexity and no output schema, it is mostly complete for an agent to understand the tool's role in the upload process.

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

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

With only 33% schema description coverage, the description adds no parameter-level information. It does not explain the purpose of brandId, files, or categoryId, nor does it clarify the structure of the files array items. The schema's description for fileType is present, but the description text itself offers no parameter semantics.

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

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

The description clearly states the tool's purpose: to reserve an upload and return a presigned S3 PUT target and uploadId. It specifies the two-step flow involving confirm_asset_upload, differentiating it from siblings like confirm_asset_upload and cancel_asset_upload.

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

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

The description explains the intended workflow, including that the client performs the PUT out of band and then calls confirm_asset_upload. However, it does not explicitly state when not to use the tool or provide alternatives, though the sibling context and process description offer implicit 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 description is consistent with the readOnlyHint annotation. However, it lacks details about pagination, rate limits, or the structure of the response (e.g., whether it returns all assets or a paginated list). Additional context beyond the annotation scope would improve transparency.

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

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

The description is a single, front-loaded sentence that efficiently conveys the purpose and optional filters. No extraneous information.

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

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

Given no output schema and 5 parameters, the description provides a high-level overview but omits important context like pagination behavior, result ordering, or response format. For a list operation, more detail on what is returned would enhance 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 only 20% (only brandId has a description). The tool description groups the filters ('brand/type/status/tag/campaign') but does not explain the meaning of tags or campaignId. The enums for type and status are self-explanatory, but missing descriptions for tags and campaignId leave ambiguity.

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

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

The description clearly states the verb 'list' and the resource 'assets', specifies the scope ('in the caller's organization'), and lists the optional filters. This distinguishes it from sibling tools like list_brands or list_brand_dna_versions.

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

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

No explicit guidance on when to use this tool versus alternatives like list_brands or list_recent_tasks. The description implies usage for listing assets with optional filters but does not provide when-not-to-use 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?

Annotations already provide readOnlyHint=true, indicating a safe read operation. The description adds context that it lists 'all' versions, but does not disclose additional behavioral traits like result format or pagination. It neither contradicts annotations nor adds substantial value beyond them.

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

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

The description is a single sentence, front-loaded with the action and resource, with no wasted words. 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?

Given the simplicity of the tool (one parameter, no output schema), the description is adequate but incomplete: it does not mention what the output contains (e.g., list of version objects). The absence of an output schema increases the need for descriptive completeness, which is partly unmet.

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

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

Schema description coverage is 100% for the single parameter brandId, which is described as 'brand UUID'. The description does not add extra meaning beyond what the schema provides; it simply restates the context ('for a brand'). Baseline score of 3 is appropriate.

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

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

The description 'List all Brand DNA versions for a brand' uses a specific verb (List) and resource (Brand DNA versions), clearly distinguishing it from sibling tools that perform other operations like activate, create, or delete.

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

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

No explicit guidance on when to use this tool versus alternatives such as get_brand_dna_version (single version) or get_active_brand_dna. The context signals include many related sibling tools, but the description does not differentiate use cases.

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 adds value by specifying the scope 'in the caller's organization'. However, it does not disclose pagination behavior, default sorting, or result limits, which could be important for usage.

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

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

The description is a single sentence with front-loaded purpose. It is concise and free of extraneous detail, though it could be slightly expanded to include sortBy parameter guidance without losing brevity.

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

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

For a list tool with no output schema, the description omits any indication of the return format, which would be helpful. It adequately covers scope and filters but lacks completeness regarding output expectations and default 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%, so the description must compensate. It only mentions 'industry/name filters', partially covering two parameters, but ignores sortBy entirely. No explanation of parameter semantics, validation, or defaults is provided, leaving the agent under-informed.

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

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

The description clearly states the verb 'list' and the resource 'brands', with scope 'in the caller's organization' and optional filters. This distinguishes it from sibling tools like get_brand (single brand) and create_brand (creation), making the purpose 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 description provides context for optional filters (industry/name), implying when to use them, but lacks explicit guidance on when not to use the tool or alternatives. No comparison with sibling tools like search or filter variants is given, so the agent has limited direction for tool selection.

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

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

The annotations already declare readOnlyHint=true, indicating a read-only operation. The description adds no behavioral context beyond that (e.g., rate limits, data freshness, sorting defaults). There is no contradiction, but the description does not enhance transparency.

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

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

The description is a single concise sentence that front-loads the main action and key options (brand, partner filter, pagination). No wasted words, though it could be slightly longer to include parameter details.

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

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

Despite 6 parameters and no output schema, the description covers the essential aspects: brand ID (required), partner filter, and pagination. Sorting is implicit, but for a listing tool this is reasonably complete.

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

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

Schema coverage is 50% (3 of 6 parameters documented in schema). The description adds value by naming the partner filter and pagination, but does not explain sortBy or sortOrder, which remain opaque. Overall adds some meaning but not comprehensive.

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

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

The description specifies the verb 'list' and the resource 'image-to-video generation groups for a brand', with optional filters (partner and pagination). It clearly distinguishes from sibling tools that list other entities (e.g., list_assets, list_brands, list_scene_forges).

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

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

The description mentions the tool is for listing groups for a brand with optional filters, but provides no explicit guidance on when to use this tool versus alternatives, nor any when-not or exclusion criteria. Usage is implied but not explicitly differentiated.

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?

Matches annotation readOnlyHint=true with explicit 'Read-only'. Adds behavioral context: purpose is to recover ids, and each entry's task_id is consumed by other tools. 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?

Two sentences that are front-loaded and efficient. No wasted words; every sentence provides essential information.

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

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

Covers use case, relationships to other tools, and read-only nature. Does not describe return format, but no output schema is provided. Adequate for a simple list tool.

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

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

Schema coverage is 100%, so the schema already explains all parameters. Description adds no additional semantic value for parameters beyond stating the tool's overall purpose.

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

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

Describes a specific action (list recent async tasks) and resource (async tasks including prompt-enhancement ids). Distinguishes from siblings by noting that no other list tool covers prompt-enhancement ids.

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

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

Explicitly states when to use: to recover task ids after a disconnect. Mentions uniqueness of including prompt-enhancement ids. Does not explicitly state when not to use or provide alternatives, but context is clear.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds the scope of listing generations with filters, which is helpful but does not disclose any additional behavioral traits beyond what the annotation provides. No contradiction with annotations.

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

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

The description is a single sentence that efficiently conveys the core purpose and optional parameters. No fluff or redundant phrasing.

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

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

Given the 7 parameters and no output schema, the description is minimal. It does not explain the return format, how pagination works beyond schema details, or provide context for enum values. It covers the basics but leaves gaps for a complete understanding.

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

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

Schema description coverage is 43% (brandId, page, limit described in schema). The description adds high-level context for status, partner, page, and limit but does not cover sortBy and sortOrder. It adds some meaning beyond the schema but is not comprehensive.

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

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

The description clearly states the action (List), the resource (Scene Forge image generations), and the scope (for a brand). It also mentions optional filters and pagination, which distinguishes it from sibling tools like enhance_scene_forge_prompt or scene_forge that do not 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?

The description implies when to use the tool (to list generations for a brand) but does not explicitly exclude alternatives or state when not to use it. However, the specificity of 'Scene Forge image generations' effectively differentiates it from sibling list tools like list_assets or list_brands.

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?

Describes RFC 7386 JSON Merge Patch semantics, nested deep-merge, null deletion, atomic write-back. Adds substantial context beyond annotations (idempotentHint, destructiveHint). 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?

Two sentences plus example, front-loaded with purpose, then behavioral details. No wasted words.

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

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

With 3 params, no output schema, annotations present, description thoroughly explains merge patch behavior and provides example, making it complete for the tool's complexity.

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

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

Schema coverage is 100%. Description adds meaning: explains patch format (RFC 7386, snake_case, null), gives example. For brandId and versionId, adds 'UUID' context already in schema. Good value but not exceptional.

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

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

Clearly states 'partially update a Brand DNA version's canonical payload' with specific verb 'patch' and resource. Distinguishes from siblings like update_brand_dna_version by emphasizing partial update vs. full replacement.

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 when to use: 'send ONLY the fields to change' and 'so you never echo the whole DNA'. Implicitly contrasts with update_brand_dna_version. Could be improved by explicitly mentioning not to use for full updates.

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?

Disclosures beyond annotations: async return of task id, SSRF restrictions on URLs. No contradiction with destructiveHint=false. Adds clarity on behavioral traits.

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

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

Two sentences, no wasted words. Front-loaded purpose, then async behavior and restrictions. Every sentence adds value.

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

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

Covers core aspects: what it does, async nature, polling instruction, URL restrictions. Lacks mention of possible side effects or status transitions, but sufficient given complexity and no output schema.

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

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

Schema coverage is 100%, baseline 3. Description adds context that assetIds and urls are 'replacement' sources, but schema already includes comparable descriptions. No additional format or usage details beyond schema.

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

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

Verbs 'reset' and 're-run extraction' clearly state the tool's action. Distinguishes from siblings like 'patch' or 'activate' by describing the reset-and-replace behavior.

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

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

Description mentions asynchronous nature and polling get_task, but does not explicitly state when to use this tool versus alternatives like 'patch_brand_dna_version' or 'update_brand_dna_version'. Lacks explicit when-not or alternative context.

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

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

Discloses async behavior (returns task id, poll get_task), emphasizes Brand DNA improves results, and notes the tool is non-destructive (consistent with annotations). Adds value beyond the minimal 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?

Front-loaded with main action, then key workflow details. No wasted sentences; each sentence provides essential behavioral or procedural guidance.

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, description covers return value (task id) and polling. Explains prerequisite workflow with Brand DNA, which is critical for successful use. Addresses complexity of 9 parameters by focusing on the most important behavioral context.

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

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

Schema description coverage is 100%, so baseline 3. The description does not elaborate on individual parameters beyond what the schema provides, but the schema itself is thorough.

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

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

Clearly states 'Start a Scene Forge image generation for a brand' with specific verb and resource. Distinguishes from siblings like enhance_scene_forge_prompt and get_task by calling out the core generation action.

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 instructs to call get_active_brand_dna first, offer to create/activate Brand DNA if none, and only proceed if user declines. Also notes asynchronous polling for completion via get_task.

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

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

Annotations already indicate idempotent and non-destructive. The description adds that omitted fields are preserved, aligning with and extending annotation info without contradiction.

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

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

The two-sentence description is concise and front-loaded with key information, though a bit more structure could enhance clarity.

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

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

With no output schema and 9 parameters, the description lacks return value info and does not cover all parameter semantics, leaving gaps for a complex 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 description mentions 'name, descriptors, logo' but the schema has 9 parameters with only 22% coverage. It adds meaning for some but not all parameters, insufficiently compensating for low schema coverage.

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

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

The description clearly states the tool updates a brand's fields (name, descriptors, logo), specifying verb and resource. It distinguishes itself from siblings like create_brand and get_brand.

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

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

The description explains partial update semantics (only passed fields change) and advises using get_brand first for current values, providing clear when and how to use.

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

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

The description discloses the overwriting behavior for dna payload and the need for a concurrency token. Annotations already indicate destructiveHint=false, so the description adds value by explaining the optimistic locking mechanism and the conditional overwrite.

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 only, with no redundancy. Every word adds value, making it efficient and easy to parse.

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

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

For a mutation tool with 5 parameters and no output schema, the description covers inputs, preconditions, and two use cases. The nested dna object is briefly described in the schema but not elaborated, which is acceptable given schema coverage.

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

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

Schema coverage is 80%, with descriptions for 4/5 params. The description adds meaning by clarifying that updatedAt is a concurrency token from a prior read, that dna is optional and overwrites the blob, and that name is for renaming. This goes beyond the schema brief.

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 allows renaming a Brand DNA version and/or overwriting its canonical DNA payload. It uses specific verbs ('Rename' and 'overwrite') and identifies the resource. The purpose distinguishes it from siblings like activate, delete, or patch.

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

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

The description provides explicit guidance on passing the updatedAt as an optimistic-lock token from get_brand_dna_version and omitting dna for a rename-only update. While it does not mention when not to use this tool, the context of rename vs overwrite and lock token requirement is helpful.

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