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?

The description goes beyond the annotations by disclosing key behaviors: deferred payment settlement (charged only on successful generation, never on failure), async job_id return, typical 5-15 minute runtime, and the free polling mechanism. This adds critical context that the annotations (readOnlyHint=false, openWorldHint=true) do not cover.

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 'PAID' and the core purpose, followed by the pipeline and payment terms. It is somewhat redundant with the bracketed payment clarification but each sentence contributes. Slightly verbose due to repeated payment info, but still concise overall.

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, asynchronous, multi-step generation tool with no output schema, the description explains the job_id return and polling workflow, which is essential for the agent. It does not cover error cases or output format details, but the schema and context signals provide substantial coverage, so 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 100% with each parameter well-described in the input schema. The description mentions 'reference photo (base64)' and 'job_id', but does not add meaning beyond the schema for parameters like polygon_tier or platform. Baseline 3 applies since the schema carries full parameter documentation.

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

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

The description clearly states the tool generates a production 3D avatar from a reference photo (base64), including the processing pipeline (xAI normalize → TRELLIS.2 GPU mesh → post-process). It distinguishes from sibling generate_avatar_from_text by specifying the image input and mentions paid status.

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: for paid avatar generation from an image, and instructs to poll with the free get_generation_status tool. It does not explicitly contrast with generate_avatar_from_text, but the image-based input is clear, and the payment and polling workflow is well defined.

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

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

The description goes far beyond annotations by disclosing the payment model (deferred settlement, never charged on failure), the asynchronous job_id return, and the processing pipeline. It provides important behavioral context such as cost and failure handling, with no contradiction to the annotations.

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

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

The description is informative but includes redundant payment details (the paid info is stated twice, once at the start and again in the bracketed note). It is not excessively long, but the repetition and bracketed aside make it less concise 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?

The description covers the payment, async job_id return, polling via get_generation_status, and typical runtime, which is complete for a complex paid tool. It does not explain error scenarios or how to interpret job_id beyond polling, but the schema and context signals cover most operational 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 covers all 5 parameters with detailed descriptions and enums (100% coverage), so the description adds no additional semantic value for parameters. It only mentions 'text prompt' generically, which is already in the schema. Baseline 3 is appropriate.

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

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

The description clearly states it generates a production 3D avatar from a text prompt, describing the specific pipeline (xAI concept image → TRELLIS.2 GPU mesh → post-process). This distinguishes it from sibling tools like generate_avatar_from_image by explicitly specifying the text-to-avatar workflow.

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

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

It explicitly instructs polling with the free get_generation_status tool and mentions typical runtime, which is practical usage guidance. However, it does not explicitly contrast with alternatives like generate_avatar_from_image or state when not to use this tool, so it stops short of a full when/when-not/alternatives guide.

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, but the description adds valuable behavioral context: it's free, returns download URLs only after deferred payment settles, and reports charged=false on failure. These were not present in the annotations.

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

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

Two compact sentences plus a bracketed free note. Every word earns its place, front-loaded with 'FREE' and the core polling 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?

For a one-parameter poll tool with no output schema, the description fully covers return behavior (status/progress, URL availability, failure flag), payment context, and cost. No significant gaps remain.

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

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

Schema coverage is 100% with a clear description for job_id ('Job id returned by a generate tool'). The description adds minimal new meaning, simply reinforcing the polling context. Baseline 3 is appropriate.

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

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

The description clearly states the tool polls generation jobs submitted by paid generate tools, returns status/progress, and provides download URLs when complete. It distinguishes itself from the generate sibling tools by being the status-checking counterpart.

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

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

It explicitly says to poll a generation job submitted by the paid generate tools, implying this is the follow-up tool after using those. It doesn't name alternatives but the context is clear, with the 'FREE' note reinforcing when to use it.

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

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

Annotations already declare readOnlyHint, 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.