three.ws 3D Studio (free)

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

Annotations already declare readOnlyHint=true and destructiveHint=false, indicating safety. The description adds the polling behavior: updated timing during rendering and need to call again after a suggested wait, plus inline rendering upon completion. This provides useful behavioral context beyond annotations.

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

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

The description is concise with three sentences, front-loaded with purpose, followed by usage instructions, and ending with the outcome. Every sentence adds value without redundancy.

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

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

Given the tool's simplicity (1 parameter, no output schema), the description adequately covers the polling flow and final result. It does not detail error cases or response fields, but for a straightforward check tool, it is sufficiently 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 the job_id parameter fully described in the schema. The description reinforces that the job_id comes from a pending result, adding minimal extra meaning. Baseline 3 is appropriate.

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

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

The description clearly states the tool checks on a pending 3D generation and collects the finished model, using the verb 'check' and specifying the resource. It distinguishes from sibling tools like create_agent_persona and forge_avatar, which involve creation or modification, not status polling.

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

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

The description explicitly says to use this tool when a generation returns status 'pending' and to pass the job_id. It provides instructions for repeated calls with a suggested wait. While it doesn't list alternatives among siblings, the context signals show siblings are distinct operations.

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 write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds behavioral context: the model is copied into durable storage, the returned view renders a living body that idles, and it can be used with persona_say. It also notes no sign-in required, which is useful beyond the annotations.

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

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

The description is a coherent paragraph of 5 sentences. It is mostly efficient, though some sentences like 'The returned view renders the LIVING body inline' could be integrated with later points. Overall, it is appropriately sized and 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?

With no output schema, the description explains the return value: a view that renders the living body, and the persona_id handle. It covers the tool's function, parameters, and subsequent usage. Given the tool's moderate complexity (4 parameters, 2 required), this is sufficient.

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

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

Schema coverage is 100%, so all parameter descriptions exist in the schema. The description does not add per-parameter details beyond what the schema provides, but it provides collective context about the purpose of the parameters (e.g., glb_url is the source, name is the display name). Thus, it adds marginal value over 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 action ('turn'), the resource (GLB into a persona), and the purpose (persistent reuse across sessions). It distinguishes from sibling tools like forge_avatar (which generates the GLB) and persona_say (which later uses the persona).

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 context of use: after generating a GLB, to create a persistent persona. It mentions the returned persona_id for later use with get_agent_persona or persona_say, guiding usage. However, it does not explicitly state when not to use this tool versus alternatives like forge_free.

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 by explaining the one-step mesh generation and rigging process and mentioning inline rendering. However, it does not disclose whether the avatar is saved, its persistence, or other side effects beyond viewing, which would be valuable given there is no output schema and annotations only provide basic read/write 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 three sentences, each serving a distinct purpose: core functionality, process explanation, and usage guidance. It is front-loaded with the key action and has no filler or redundant text.

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

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

The description explains the output format (GLB), immediate rendering, and distinguishes from siblings in the context of characters vs objects. However, it lacks details on whether the generated avatar is stored, how to retrieve it later, or any limitations (e.g., polygon count). Given the absence of an output schema, adding such details would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some extra meaning by explaining the overall workflow ('from a single text prompt or a reference image' and 'auto-rigs it with a humanoid skeleton') which implicitly relates to the parameters, but does not significantly enhance the semantic understanding beyond what the schema already provides.

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

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

The description clearly states the tool generates a rigged, animation-ready 3D avatar from a text prompt or reference image in one step. It specifies the verb 'generate', the resource 'rigged, animation-ready avatar', and distinguishes from siblings by noting that objects are steered to the mesh generator.

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

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

The description provides clear guidance: 'Best for characters; objects are steered to the mesh generator.' This explicitly tells the agent when to use this tool versus siblings like mesh_forge. However, it does not elaborate on all scenarios where this tool should be avoided (e.g., when a non-humanoid rig is needed without special flag).

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 write operation with potential side effects. The description adds behavioral details: renders inline, high tier may fall back to standard under load. No contradiction with annotations.

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

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

Two sentences, front-loaded with core purpose and key details. No superfluous 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?

Covers output (GLB, interactive viewer), constraints (single object, free), and performance note (tier fallback). No output schema, but description sufficiently informs the agent of expected 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 coverage is 100% with detailed descriptions. The description adds value by emphasizing 'single object' for the prompt and explaining the tier fallback behavior, which is not 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 the tool generates a 3D model from text, specifies free, GLB output, and interactive viewer. It does not explicitly differentiate from sibling tools like forge_avatar or mesh_forge, but the purpose is distinct 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 advises describing a single object, character, or creature, which gives context for when to use. However, it lacks explicit guidance on when not to use (e.g., complex scenes) and does not mention alternative 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 indicate readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is clear. The description adds what is returned (name, model, turn count, living-body view), providing useful behavioral context beyond annotations.

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

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

Two sentences front-load the core action and then provide usage guidance and return info. Every word is necessary; no waste.

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, but the description lists what is returned (name, model, turn count, living-body view). For a simple retrieval tool, this is moderately complete. Could elaborate slightly on the 'inline living-body view' or error conditions.

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

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

Schema coverage is 100% for the single parameter. The description mentions 'persona_id returned by create_agent_persona', which adds slight context, but overall does not significantly enhance the schema's own 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 clearly states the verb 'bring back' (reload) and the resource 'persona by its persona_id', distinguishing it from sibling tools like create_agent_persona.

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?

Explicit guidance: 'Use this at the start of a conversation when the user returns to a named agent.' This tells when to use and implies not to use for new personas.

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

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

Annotations include openWorldHint=true, so the description should disclose side effects. It adds context about the AI art-director refinement and inline rendering, but does not mention potential costs, duration, or output behavior beyond the viewer. The description partially compensates for missing annotation 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 (two sentences, 55 words) and front-loads the core purpose. Every sentence adds value, with no redundancy or filler.

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

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

For a tool with two optional parameters and no output schema, the description explains the main workflow (text or image) and a key behavioral aspect (art-direction). However, it omits details about what happens when both inputs are provided and does not clarify the return format or how the inline viewer is presented.

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?

Input schema covers 100% of parameters with descriptions. The description reinforces that prompt is for a single subject and that image_url is optional, but adds little new meaning beyond the schema. The art-director refinement is mentioned but not tied to a specific parameter.

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

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

The description clearly states that the tool generates a textured 3D mesh (GLB) from a text prompt or reference image URL. It includes an art-direction step for text prompts, which distinguishes it from simpler generation tools. However, it does not explicitly differentiate from siblings like forge_free or text_to_avatar, which may overlap.

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

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

The description provides no guidance on when to use this tool versus its siblings (e.g., forge_avatar, forge_free) or alternatives. It implies a single-subject focus but does not state exclusions or when not to use it.

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

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

Discloses that the tool animates the body (lip-sync, emotion, gesture) and returns a view. Annotations show non-destructive and non-read-only, which aligns. Does not detail state persistence but is sufficient for an animating tool.

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

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

Two sentences, first defines purpose, second provides usage details. No fluff, 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?

Covers essential use-cases (turn-by-turn reply). Lacks output schema, but hints at returned view. Could mention prerequisites like persona existence, but overall complete enough for a simple 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 baseline 3. Description adds that emotion can be auto-detected or explicit, which reinforces schema but doesn't add substantial new semantics beyond 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?

Clearly states the tool makes a persona perform a reply with lip-sync, emotion, and gesture. Distinguishes from sibling tools (create_agent_persona, forge_avatar, etc.) by focusing on speaking through an existing persona.

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 usage context: pass persona_id and text for turn-by-turn embodiment. Implicitly indicates when to use (when you want persona to speak), but doesn't explicitly state when not to use or name alternatives.

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

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

The description reveals key behaviors: re-generation anchored to the previous model, carrying form and materials forward, and recording lineage for versioning. It also mentions inline rendering in the 3D viewer. This adds significant context beyond the annotations (which only indicate non-read-only and non-idempotent). 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 concise (≈100 words) and well-structured: first sentence summarizes purpose, then details usage and behavior, and concludes with output expectations. Every sentence contributes value without redundancy.

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

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

Given the tool has 6 parameters (2 required) and no output schema, the description covers all critical aspects: what the tool does, how to use required and optional parameters, the refinement process, and what the user can expect (lineage, inline rendering). It is complete enough for an agent to use 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?

All 6 parameters have descriptions in the schema (100% coverage), but the description adds meaningful context: it explains that glb_url comes from a previous generation, instruction is plain language, and parent_lineage extends version history. This helps an agent understand parameter relationships beyond simple types.

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: iterating on a generated model by describing a change. Examples like 'make it metallic' and 'bigger helmet' concretely illustrate the input. The tool is distinguished from sibling tools (e.g., mesh_forge, forge_avatar) by focusing on refinement of existing models rather than creation from scratch.

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

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

The description explains when to use the tool: when you have a previous model and want to modify it. It details how to use required parameters (glb_url, instruction) and optional ones for branching (parent_lineage, parent_index). While it does not explicitly contrast with siblings or state when not to use, the context is clear enough for an agent to select this tool over 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 discloses behaviors beyond annotations: it auto-rigs, adds skeleton and skin weights, and renders the result inline in an interactive 3D viewer. Annotations indicate readOnlyHint=false, openWorldHint=true, etc., and the description does not contradict them. It adds useful context about the inline rendering.

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

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

The description is two sentences, front-loaded with the main purpose, and contains no unnecessary words. It is efficient and well-structured.

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

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

For a tool with one input parameter and no output schema, the description is complete: it explains what the tool does, what input is needed, and what happens after processing (inline rendering). It also contextualizes the input as possibly from other tools.

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

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

There is only one parameter (glb_url) with 100% schema description coverage. The tool description adds meaning by stating the URL likely comes from other tools, providing additional context beyond the schema's 'http(s) URL to the static GLB mesh to rig'.

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 that the tool auto-rigs a static 3D model (GLB) into an animation-ready model by adding a humanoid skeleton and skin weights. It also mentions providing a GLB URL, which aligns with the tool name 'rig_mesh'. However, it does not explicitly distinguish this tool from sibling tools like 'forge_avatar' or 'mesh_forge', though it hints at working with outputs from other tools.

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

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

The description gives explicit guidance on when to use: when you have a static GLB model and want to rig it for animation. It also suggests the GLB URL may come from other tools, providing context. However, it does not mention when not to use or name alternatives among the sibling tools, though the use case 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 description adds behavioral context beyond annotations (output format GLB, interactive viewer). Annotations provide readOnlyHint=false and openWorldHint=true, which the description does not contradict.

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

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

Two sentences, front-loaded with action, no redundancy. 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 tool with 2 optional parameters and no output schema, the description covers purpose, inputs, output format, and viewer. It lacks error cases or limitations, but is sufficient for basic use.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions input types (text, image URL) but adds little beyond the schema descriptions, except 'Best for characters and figures' which is minimally informative.

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 textured 3D avatar from text or image, specifying output format (GLB) and inline viewer. However, it does not differentiate from sibling tools like forge_avatar or mesh_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?

The phrase 'Best for characters and figures' gives implicit guidance, but there is no explicit when-to-use or when-not-to-use advice, nor mention of alternatives.

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