AXIS Avatar Foundry

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety profile. The description adds valuable operational context: it discloses the paid nature ($0.10 USDC via x402) and the condition that payment is settled only on successful results. It also mentions the return format (similarity score and diffs), going beyond what annotations provide. 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 exactly two sentences: the first clearly states the core function, and the second provides essential payment information. No wasted words, and the critical purpose 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?

The tool is simple with a well-covered schema and annotations. The description adds the return value ('similarity score and section-level diffs') and the payment caveat, which is important for an agent. No output schema exists, so describing the return structure is helpful. However, it doesn't explain what 'section-level diffs' entails, leaving some ambiguity for unfamiliar agents, but overall it is complete enough for selection and invocation.

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

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

The input schema has 100% description coverage for all three parameters (file_a, file_b, sections), so the schema already explains their meaning. The description does not add any additional parameter-specific details, such as format hints or examples, beyond what the schema provides. Baseline of 3 is appropriate.

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

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

The description states a specific verb ('Compare') and resource ('avatar contracts'), and distinguishes itself from sibling tools by mentioning the unique output ('similarity score and section-level diffs'). The title 'Compare Two Meshes' reinforces the purpose, making it unmistakable.

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

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

The description clearly implies the tool is for comparing two meshes/avatar contracts, which provides some context for when to use it. However, it does not explicitly mention alternatives or when-not scenarios, leaving usage guidance to inference. This is implied usage rather than explicit guidance.

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

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

Annotations already provide safety hints (readOnlyHint=true, idempotentHint=true). The description adds valuable behavioral context beyond these: the payment requirement for unauthenticated calls ($0.50 USDC via x402) and the settlement condition (only on successful results), as well as the HMAC-signed manifest output. This exceeds the baseline and provides genuinely useful operational details.

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

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

The description is extremely concise: a single, front-loaded sentence states the core purpose, followed by a brief pricing note. Every sentence provides necessary information with no filler, achieving high efficiency and 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?

Given the tool's low complexity (2 parameters, no nested objects, no output schema) and rich annotations, the description is largely complete. It covers purpose, validation, manifest signing, and payment behavior. The only minor gap is not describing the exact return format, but that is not critical for a tool of this simplicity.

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% because both parameters have descriptions ('Target platform' and 'Path to mesh file'). The description adds no further parameter-specific meaning; it only restates the concept of a target engine platform. Thus, the baseline of 3 is appropriate.

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

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

The description specifies a clear action ('Export an avatar to a target engine platform') with a distinct resource (avatar) and destination (engine platform). It also distinguishes itself from sibling tools like axis_validate and axis_manifest_verify by mentioning validation and HMAC-signed manifest, making the purpose unmistakable.

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

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

The context is clear: this tool is for exporting avatars to engine platforms. It implies when to use it (when an export is needed) and distinguishes from validation or inspection tools through the action verb. However, it does not provide explicit exclusions or name alternatives, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description does not need to repeat that. It adds valuable behavioral context: the cost (USD 0.10 via x402), that it settles only on successful results, and what return fields to expect. This goes beyond the annotations without contradicting them.

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

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

The description is two concise sentences plus a bracketed note. The first sentence states the core function and lists specifics; the second directly addresses what it does not do and points to an alternative. The payment note is placed at the end, keeping the front-loaded purpose clear. Every sentence earns its place with no redundancy.

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

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

Given the tool has no output schema, the description appropriately explains what the tool returns (stage, bone/vertex counts, provenance step count, chain_valid, broken links). It also covers exclusions (no quality grade), alternative tools, and cost implications. For a single-parameter read-only tool, this is a complete and self-sufficient description.

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

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

The input schema has 100% description coverage for the single parameter file_path ('Path to mesh file'). The description does not add extra details about the parameter format or constraints, but with full schema coverage, the baseline of 3 is appropriate. The description's mention of 'mesh file' in the title aligns with 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 explicitly states the tool inspects an avatar's contract state and provenance chain, listing concrete data points (stage, bone/vertex counts, provenance step count, chain_valid, broken links). It also distinguishes itself from axis_validate by clarifying what it does NOT do (return a quality grade). This is a clear, specific verb+resource+scope description.

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

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

The description provides explicit guidance on when to use this tool versus an alternative: it states that for pass/warn/fail rule results, use axis_validate instead. It also mentions the payment condition for unauthenticated calls, which is relevant for usage decisions. This qualifies as explicit when/when-not/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 and idempotentHint, and description adds a cost disclosure (free) and enumerates content; no contradiction. Adds value beyond annotations.

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

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

Single front-loaded sentence, every element earns its place; the free note is relevant behavioral info and does not add fluff.

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

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

Tool is simple with one optional parameter; description covers purpose and content sufficiently, though no output schema means no explicit return format, but adequate given simplicity.

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 has 100% coverage with enum and property description; description reinforces the enum values in parentheses but adds no new syntax or format details, 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 uses specific verb 'List' and identifies resource 'AXIS Foundry capabilities' with explicit categories (input formats, export platforms, validation rules), clearly distinguishing from sibling tools that perform 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?

Description implies use when needing an overview of supported capabilities, but does not explicitly mention alternatives or when not to use; clear context from 'List all' with no exclusions.

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

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

Annotations already disclose readOnly, idempotent, and non-destructive hints. The description adds useful context beyond annotations: the endpoint is paid ($0.10 USDC) and settlement only occurs on successful non-error results. This is valuable behavioral information. 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 extremely concise: one sentence for core purpose and one bracketed note for payment details. Every word earns its place. The main purpose is front-loaded, and the additional payment info is a necessary disclaimer that doesn't clutter the message.

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

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

Given the tool has only two parameters and no output schema, the description explains the core operation and a notable payment behavior. However, it does not describe the return value format (e.g., boolean, report object) or error scenarios, which would be useful for a verification tool. The payment note hints at success/error but lacks detail.

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 covers 100% of parameters with descriptions for both 'manifest' and 'expected_hash'. The description's phrase 'optionally check content hash' merely mirrors that expected_hash is optional, which is already evident from the schema (only manifest is required). No additional parameter semantics are introduced.

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: verify an export manifest's integrity and optionally check a content hash. The verb 'verify' and resource 'export manifest' are specific. However, it does not explicitly distinguish itself from the sibling tool 'axis_validate', as there may be overlap in meaning between 'verify' and 'validate'.

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

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

No guidance is given on when to use this tool versus alternatives. The description simply states what it does, leaving the agent to infer context. It does not mention any exclusions, prerequisites, or direct comparisons to sibling tools like axis_compare or axis_validate.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by disclosing the payment requirement ($1.50 USDC) and the fact that it settles only on successful results, which is critical behavioral context beyond annotations.

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

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

The description is extremely concise: two sentences effectively cover purpose, pipeline steps, return type, and billing. The first sentence is front-loaded with the core action, and the second adds necessary operational context without redundancy.

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

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

The description provides sufficient context for a complex pipeline tool, including the pipeline stages and payment terms. It does not explain the contents of the contract summary, but the schema covers parameters and annotations cover safety. Overall, adequately complete.

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

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

The input schema provides full descriptions for all three parameters (file_path, export, platform) with 100% coverage. The description does not add parameter-level details beyond what the schema already offers, so the baseline score of 3 applies.

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

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

The description clearly states the tool runs the full AXIS avatar pipeline with specific steps (classify → normalize → rig → skin → validate) and returns a contract summary. This distinguishes it from sibling tools like axis_validate (which only validates) and axis_export (which only exports).

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 conveys when to use the tool: to execute the complete pipeline rather than individual steps. However, it does not explicitly mention alternatives or scenarios where other tools should be preferred, though the 'full pipeline' wording implies it includes sub-steps.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds useful context by specifying the return format (pass/warn/fail counts, detailed rule results) and disclosing the payment model (fee only on successful non-error results). This goes beyond the structured 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 two sentences, both informative. The first sentence states the core purpose and returns, the second explains billing—a useful operational detail. No wasted words, and the information is front-loaded.

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

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

For a simple validation tool with a well-defined schema and no output schema, the description adequately covers return values and cost behavior. It doesn't elaborate on error cases or rule specifics, but the '38 Rules' in the title and the schema enums provide sufficient context for an agent to invoke it correctly.

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

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

The input schema provides 100% coverage with descriptions for all three parameters, including enums for profile and platform. The description adds no additional parameter meaning beyond what is already in the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool validates an avatar mesh file with a specific verb ('Validate') and resource ('avatar mesh file'), and mentions return counts and detailed rule results. However, it does not explicitly distinguish itself from sibling tools like axis_inspect or axis_manifest_verify, though 'validate' conveys a distinct intent.

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 only states what the tool does and its cost, but gives no guidance on when to prefer this over alternatives. It does not mention exclusions, prerequisites, or scenarios where a different tool (e.g., repair_mesh or axis_inspect) would be more appropriate.

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

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

Annotations indicate a non-read-only, non-idempotent operation, but the description adds substantial detail: payment is settled only on completion, failed jobs are never charged, returns a job_id, and replaying idempotency_key returns the original job_id (no second charge). This goes well beyond annotations and discloses critical cost/behavior.

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

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

The description is dense and includes redundant repetition (the bracketed cost/settlement note mirrors the opening). While front-loaded with key facts, it over-explains and could be tightened. Every sentence is informative, but the redundancy and length reduce conciseness.

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

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

For a paid, async job tool, the description covers payment terms, job_id return, polling via get_generation_status, retry semantics, and typical runtime. No output schema exists, but the description explains what to expect. All necessary context for an agent to call and monitor the job is present.

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

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

Schema coverage is 100%, so parameters are already documented. The description adds meaningful semantics, particularly for idempotency_key (retry behavior, uniqueness per payer) and platform (adds rigging/export). It does not restate basic param meanings, but enriches them with usage context.

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

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

The description clearly states the action: 'generate a production 3D avatar from a reference photo (base64)' and outlines the pipeline (xAI normalize → TRELLIS.2 → post-process). It distinguishes from the sibling generate_avatar_from_text by specifying photo input. No ambiguity about what the tool does.

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 explains when to use: for photo-based avatar generation. It names the free get_generation_status tool for polling and instructs to pass idempotency_key on retries after timeout/5xx. Though it does not mention 'when not to use' relative to text input, the photo-only scope is stated clearly, and the polling/retry guidance is actionable.

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

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

Annotations already declare readOnlyHint=false and openWorldHint=true, so the non-read-only nature is covered. The description adds substantial value beyond annotations: deferred settlement (charged only on completion, never for failures), asynchronous behavior with job_id and 5-15 min runtime, and the idempotency_key dedup mechanism. The idempotentHint=false annotation does not contradict the idempotency_key discussion — the description explains how to achieve idempotent replay, not that the operation is inherently idempotent. Minor demerit for repeating the 'never charged' guarantee twice.

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 core content is front-loaded with the paid status and pipeline, which is good. However, the bracketed 'Paid:' tail repeats payment and settlement facts already stated in the opening ('5 USDC', 'never charged', deferral, polling) nearly verbatim. This duplication inflates the description and adds noise. The idempotency section is also stated twice (in prose and again in the schema's idempotency_key description), making the overall structure less tight than it could be.

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

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

For a complex paid, asynchronous tool with side effects, the description covers the essentials: cost, settlement conditions, polling mechanism, runtime estimate, and retry/idempotency safety. There is no output schema, so return-value documentation falls to the description; it does mention job_id is returned. It could note error/success payload shapes or edge cases beyond 'failed generation', but the operational envelope an agent needs to call this safely is well covered.

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 every parameter (prompt, platform, asset_kind, polygon_tier, texture_size, idempotency_key) already carries a meaningful description in the schema, including enums and defaults. The tool description adds little beyond what the schema states — e.g., it reiterates the idempotency_key retry semantics that the schema already documents. Baseline 3 is correct since the schema does the heavy lifting.

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

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

The description states a specific verb and resource — 'generate a production 3D avatar from a text prompt' — and specifies the pipeline (xAI concept → TRELLIS.2 mesh → post-process). The phrase 'from a text prompt' implicitly distinguishes it from the sibling generate_avatar_from_image, and the paid/async framing separates it from get_generation_status. An agent can tell exactly what this tool does and how it differs from its nearest sibling.

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

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

The description gives clear operational usage: how to retrieve results ('poll with the free get_generation_status tool'), when retries are appropriate ('after a timeout/5xx'), and how to guard them ('Pass idempotency_key'). It also signals cost-vs-alternative tradeoffs (paid vs free polling). It does not explicitly name when NOT to use this tool versus generate_avatar_from_image (e.g., when an input image already exists), which would push it to a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is covered. The description adds genuinely beyond-annotation context: the deferred-payment model (download URLs only appear once complete AND payment settles, failed jobs report charged=false, and polling is free even though generate calls are paid). This is valuable behavioral detail.

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

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

A single dense paragraph that front-loads the purpose and the key FREE distinction before covering return behavior, failure cases, and lookup methods. Slightly redundant in restating free-ness ('FREE:' prefix plus '[Free — no payment required.]'), but otherwise efficient with no wasted sentences.

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 read-only poll tool with no output schema: it covers return content (status/progress, download URLs after payment settles, charged=false on failure) and both lookup paths. The 0-required, 3-optional param ambiguity is resolved by the description. The only minor gap is not describing the shape of the progress/status values, which is acceptable without an output schema.

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

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

Schema coverage is 100% with parameter descriptions for payer, job_id, and idempotency_key, so the schema already documents all parameters. The description adds marginal value by clarifying the relationship between them (idempotency_key + payer used as fallback when job_id is lost), but this mostly restates what the schema conveys. 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?

States a specific verb and resource ('poll a generation job submitted by the paid generate tools') and precisely distinguishes this read/status tool from the payment-required sibling generate tools. The purpose is unmistakable and differentiates the tool from its siblings without opening any schemas.

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

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

Gives clear usage context: poll jobs produced by the paid generate tools, and explains the two lookup paths (by job_id, or by idempotency_key + payer as a fallback when job_id is lost). This tells the agent when and how to invoke it. It doesn't explicitly name exclusion cases, but the context is solid for a polling tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is known. The description adds meaningful behavioral context beyond annotations: the payment requirement ($1.50 USDC via x402) and the fact that payment is 'settled only on a successful (non-error) result'. It also outlines the multi-stage processing pipeline, adding transparency about the processing side effects.

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

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

The description is front-loaded with the main action and pipeline, then adds the use case and pricing in a concise manner. Each sentence earns its place; the arrow notation for the pipeline is compact and structured. It is slightly denser than necessary but remains readable and free of redundancy.

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

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

Given the tool has 5 parameters, no output schema, and sits among complex siblings, the description covers the key aspects: purpose, input format, output, use case, and payment/error semantics. It mentions the return value explicitly. Missing details like validation criteria or error behavior are minor and not essential for basic selection.

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

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

Schema description coverage is 100% and each parameter has its own description, including enums and meanings. The tool description does not add new parameter-level semantics beyond what the schema already provides, so the baseline score of 3 applies. It reiterates 'inline' for glb_base64 but doesn't expand on the other parameters.

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

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

The description uses a specific verb ('Post-process a RAW generated mesh') and clearly identifies the input format ('INLINE as base64 GLB') and output ('finished, validated GLB as base64'). It distinguishes itself from sibling tools by calling out 'the inline counterpart of axis_process' and listing the pipeline stages (normalize → mesh-repair → rig/skin → validate → export). This is precise and 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 contrasts with axis_process by stating it works with inline base64 data rather than a server file path, and notes it is intended for LLM/agent use with 'fresh TRELLIS output'. This gives clear context for when to select this tool. However, it does not explicitly list alternative tools to avoid, though the sibling list implies repair_mesh and retarget_animation could be confused.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds the payment requirement ($0.75 USDC via x402, settled only on success), which is useful behavioral context beyond the annotations. No contradiction exists between the description and annotations.

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

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

The description is two sentences with the core purpose first, followed by a pricing note. It is concise and front-loaded, though the parenthetical pricing detail adds some clutter and could be separated more clearly.

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 lacks details about the returned 'repair metrics' shape and any prerequisites, and there is no output schema to compensate. The core purpose and payment model are clear, but the return value is underspecified, leaving some contextual gaps.

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

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

Schema coverage is 100%, so the baseline is 3. The description maps 'scale/axis/degenerates/normals' to the relevant parameters (scale_unit, up_axis, remove_degenerates, fix_normals), giving them purpose and context beyond their individual schema descriptions. This adds meaning to the parameter set.

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 that the tool repairs a mesh into the AXIS canonical frame (covering scale, axis, degenerates, and normals) and returns repair metrics. This is a specific verb+resource combination that clearly distinguishes it from sibling tools like axis_validate or post_process_mesh.

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

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

The description implies usage for meshes needing canonical-frame repair, but it provides no explicit guidance on when to prefer this tool over alternatives or when not to use it. No sibling alternatives are named, and the paid aspect is not tied to usage decisions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable context beyond annotations: the paid cost ($0.75 USDC via x402), the fact that it only works with built-in clips, and the note that it reports coverage and deterministic hashes. This enriches the agent's understanding of the tool's behavior without contradicting the hints.

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

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

The description is two sentences: the first states the purpose and outcome, the second discloses the cost and payment model. Both sentences earn their place, with no redundancy or filler. It is concise, front-loaded with the primary action, and structured for quick comprehension.

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

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

Given the tool's moderate complexity (3 params, 2 required), the description covers the core functionality, cost, and a key constraint (built-in clips). It also indicates the output type (coverage + hashes) even though no output schema exists. Missing are explicit details on error behavior or output structure, but the description is adequate for an agent to select and invoke 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 input schema provides 100% description coverage for all parameters (platform, clip_name, drop_unmapped), so the baseline for this dimension is 3. The description adds no extra parameter-level detail beyond what the schema already conveys, though it does mention 'built-in' which aligns with clip_name's schema description.

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

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

The description uses a specific verb ('retarget') and resource ('built-in animation clip') and clearly states the outcome ('report coverage + deterministic hashes'). It distinguishes from sibling tools like axis_compare or generate_avatar_from_image by focusing exclusively on animation retargeting across platform mappings.

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

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

Usage context is implied: the tool is for retargeting built-in animation clips to a specific platform mapping. However, it does not explicitly contrast with alternatives or state when not to use it, so it lacks the explicit when/when-not guidance that would merit a 4 or 5.

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

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

Annotations already declare read-only, idempotent, non-destructive behavior. The description adds valuable context beyond annotations: it discloses the paid nature ($0.25 USDC via x402), that it applies to unauthenticated calls on the hosted /mcp endpoint, and that settlement occurs only on a successful non-error result. This enriches the agent's understanding of cost and failure behavior.

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

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

The description is concise and well-structured: two sentences, the first stating the core purpose, the second providing payment and settlement details. No redundant information, every sentence serves a purpose.

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

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

Given the tool has one simple parameter, no output schema, and rich annotations, the description is minimally complete. It explains the input constraint and payment behavior but does not describe what the compliance check returns (e.g., boolean, list of violations), which is significant given the absence of an output schema. The annotations cover safety, but return-value semantics are left implicit.

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

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

The schema covers file_path with a basic 'Path to mesh file', and the description adds meaning by specifying 'using canonical pipeline outputs', clarifying that the input must be a canonical pipeline output rather than an arbitrary mesh. This goes beyond the schema's generic description, enhancing parameter understanding.

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

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

The description clearly states the tool's function: 'Run Roblox R15 compliance checks against a mesh'. It is specific and distinct from sibling tools like axis_validate or axis_inspect by focusing on R15 compliance. The phrase 'using canonical pipeline outputs' further clarifies the resource context.

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

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

The description implies usage for verifying R15 compliance when canonical pipeline outputs are available, but it does not explicitly state when to use this tool versus alternatives or exclude other tools. It lacks clear when-to-use or when-not-to-use guidance, though the constraint of 'canonical pipeline outputs' provides some contextual direction.

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