three.ws for Grok

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

Goes well beyond the annotations by explaining why readOnlyHint=false: checking can persist the completed model and restart failed work on another provider. It also discloses the polling loop and the intermediate return ('updated timing'), which the annotations cannot convey. No contradiction with the declared openWorldHint/idempotentHint=false.

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

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

The polling guidance is front-loaded and useful, but the final sentence almost verbatim repeats the opening sentence, wasting space. The middle clause about saving and restarting is dense and could be split for scanability.

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 carries the burden of describing returns and does so: updated timing while pending, inline rendering in the 3D viewer when done, and the suggestion to call again. Nothing needed to invoke it correctly is missing.

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

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

Schema coverage is 100%, so both job_id and the nested refine object are already fully documented, including the 'pass it back unchanged' caveat. The description only restates that job_id comes from the pending result and says nothing about refine, so the baseline 3 applies.

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

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

States a specific verb and resource: check a pending 3D generation and collect the finished model. The scope (only jobs that returned "pending") is explicit. It does not, however, distinguish itself from the sibling get_job, which an agent will reasonably confuse with this polling tool.

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 a clear trigger condition: 'Use this when a generation tool returned status "pending" and you need to collect the finished model', plus the polling cadence ('call again after the suggested wait'). No explicit exclusion versus get_job or get_item_source, so it stops short of full routing guidance.

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

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

Beyond the annotations (readOnly=false, openWorld=true, idempotent=false), it discloses that the model is copied into durable storage, that the body survives the source URL expiring, that there is no sign-in requirement, and what the returned view does (idles, lip-syncs via persona_say). That is meaningful behavioral context the annotations do not provide.

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?

It is dense but front-loaded, leading with the core purpose before the persistence and return-view details. Sentences largely earn their place, though the living-body/render description runs slightly long.

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 steps in to explain what the caller gets back (an inline living-body view) and how to reuse the persona_id. For a 4-param creation tool, nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds framing around glb_url (embodying a rigged model, e.g. from forge_avatar) and the persona_id handle, but the voice and source_prompt semantics come from the schema, so this stays at the baseline.

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

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

The description states a specific verb and resource ("Turn a generated GLB into a NAMED, persistent agent body: a 'persona'") and clarifies the persistence model. It differentiates from siblings by naming get_agent_persona and persona_say as the consumers of the returned persona_id.

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

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

It gives a clear trigger condition: "Use this once a rigged model should become a recurring character the assistant speaks through," and routes the agent to later tools. It stops short of stating when NOT to use it (e.g., one-off render vs. persistent body), but the context is strong.

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 cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds useful behavior: the mesh-then-rig pipeline, GLB output, inline 3D viewer rendering. It does not clarify job/async semantics despite the presence of check_job/get_job siblings, and the idempotency_key parameter's interaction with idempotentHint=false is left to the schema.

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

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

Front-loaded with the core action and the one-step benefit, with no wasted preamble. It is somewhat repetitive, restating 'rigged, animation-ready' and 'in one step' across three sentences, which costs it the top score.

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 exists, and the description compensates by naming the return artifact (GLB) and the presentation (inline interactive viewer). For a 4-param generation tool it is nearly complete; only the async/job lifecycle is unaddressed.

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 modest value by stating it accepts 'a single text prompt or a reference image,' implying the two input modes, but it says nothing about allow_non_humanoid or idempotency_key beyond what the schema already documents.

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 (generate), a concrete resource (rigged, animation-ready 3D avatar in GLB), and the exact pipeline (mesh generation then auto-rigging with a humanoid skeleton). It also distinguishes itself from the sibling mesh_forge + rig_mesh path by emphasizing it does both 'in one step.'

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 names the selection condition ('when the user wants a posable, animation-ready character in one step instead of generating then rigging') and routes non-character subjects away ('objects are steered to the mesh generator'). Both the when-to-use and the alternative are given.

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

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

Annotations declare a non-read-only, open-world, non-idempotent, non-destructive operation, and the description usefully adds tier trade-offs (high is slower and may silently fall back to standard) plus the 24-hour idempotency window. The one wrinkle is that idempotentHint=false alongside an idempotency_key parameter is left unreconciled, but it is not a direct contradiction.

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

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

The core capability and the 'single object' constraint are front-loaded, and the sentences are dense with useful facts. There is some mild redundancy between 'interactive model you can rotate, view, and download' and 'renders inline in an interactive 3D viewer.'

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 does the work of explaining what comes back: a GLB rendered in an inline interactive viewer, downloadable. Tier degradation and retry semantics are covered; only cross-sibling routing guidance is missing.

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

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

Schema coverage is 100%, so all three parameters including tier enum and idempotency_key are already documented in the schema. The description restates tier behavior and the single-object constraint rather than adding new syntax or semantics, so baseline 3 applies.

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

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

The description states a specific verb and resource: converts a text prompt into a textured, downloadable GLB 3D model, with the constraint of a single object/character/creature. It is clear and concrete, but it never names the closest siblings (forge_avatar, mesh_forge, text_to_avatar), so the agent must infer which one to pick.

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

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

It gives an explicit trigger: 'Use this when the user wants a new 3D object, character or creature from a text description.' However, it offers no when-not conditions or named alternatives (e.g. refine_model for edits, forge_avatar for avatars).

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 readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds genuinely new behavioral context: the persona comes back in a fresh session with continuity (accumulated turn count preserved) and an inline living-body view. It does not discuss failure modes for a stale or unknown persona_id.

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

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

Three short clauses: what it does, what it returns, when to use it. Front-loaded with the core action and no filler or redundancy.

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

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

With no output schema, the description correctly takes on the burden of listing return values (name, model, turn count, living-body view). Combined with annotation-covered safety and a fully described single parameter, an agent has everything needed to select and call it.

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 the single parameter is fully documented as 'the persona_id returned by create_agent_persona.' The description reinforces that the id addresses an existing saved persona but adds no format, length, or lookup detail beyond the schema, so the baseline 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 gives a specific verb + resource ('Bring back a previously saved persona by its persona_id') and even enumerates what is restored (same body and identity, fresh session). It implicitly separates itself from create_agent_persona via 'previously saved,' but never names that or any other sibling, so the differentiation is inferred rather than stated.

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

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

It gives an explicit trigger: 'Use this when a conversation starts and the user returns to a named agent.' That is clear context, not just implied usage. However, it offers no negative guidance (e.g., what to do if the persona_id is unknown, or that this must not be used to create a new persona).

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 readOnly/idempotent/non-destructive/openWorld=false, so the safety profile is covered. The description adds context the annotations cannot: 'Free, no account needed' (auth requirement) and an enumeration of what gets returned (metadata, license, CDN urls, site links, related items, emittable source frameworks). It does not discuss failure behavior for an unknown id.

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

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

Front-loaded with the most decision-relevant fact ('Free, no account needed'), then contents, then usage. The middle enumeration of return fields is dense but each clause is informative; nothing is redundant with the schema.

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

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

No output schema exists, so the description carries the burden of describing the payload, and it does so item by item, plus auth and usage context. The only omission is behavior on a missing or malformed id, which is minor for a single-item read.

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 and the schema already documents the id format. The description nudges above baseline by supplying a concrete example value ('object:adjustable_wrench') and by tying the id's provenance to search_catalog, which helps an agent construct a valid call.

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 ('Read one three.ws catalog item in full by its id') and names the sibling it complements ('from search_catalog') and the one it is not ('get_item_source'). An agent can distinguish it from search_catalog and get_item_source without opening any schema.

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 routing: 'Use this after search_catalog to inspect one result before you embed it; for paste-ready code call get_item_source instead.' It names both the precondition (after search_catalog) and the alternative with the condition that selects 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 cover the read-only/idempotent/non-destructive safety profile, so the bar is lower, but the description still adds substance: no account needed, SRI-pinned versions, per-framework output, and special handling for motion clips. It does not describe response shape/pagination, but as a read tool with no output schema it discloses the important behavioral traits.

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

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

Dense and front-loaded with the core promise ('free, no account needed... returns working code'), then enumerates variants and defaults. Slightly long but every sentence, including the age/license routing note, carries operational 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?

There is no output schema, so the description assumes the burden of describing returns, and it does: the four code variants, the default-selection behavior, the `all` mode, and motion-clip output. An agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so baseline is 3, but the description adds genuine semantics: omitting `framework` yields the best-fit variant, and `all` returns every applicable variant. It also explains that motion clips route to three.js code, which the schema does not convey.

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+resource: returns working, paste-ready code that renders one catalog item across four named output forms. It also distinguishes itself from the sibling get_catalog_item by naming that tool for metadata/license needs.

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

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

Explicitly says when to use it ('when you are ready to put a catalog item on a page or in an app') and names the alternative for a different need ('call get_catalog_item first if you still need its license or metadata'). Both the trigger and the exclusion are stated.

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

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

Adds substantial context beyond the annotations: it separatedly enumerates the pending/done/failed return payloads, states the tool "never starts or repeats a generation," and specifies a polling interval. This also reconciles the unusually readOnlyHint=false annotation by making clear no new generation is triggered, matching idempotentHint=true.

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?

One dense paragraph with no filler; every clause carries information (states, return fields, cadence, trigger). It is slightly back-loaded, since the 'use this when' trigger sits after the return-shape and polling details rather than at the front.

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 carries the full burden of describing return values and does so for all three terminal states, including viewer_url/glb_url/embed_html when done and the failure reason path. Nothing needed to call or interpret it correctly is missing.

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

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

Schema coverage is 100%, so both `job_id` and `refine` are already documented in the schema. The description only restates that job_id comes from a generation tool with status 'pending' and never mentions the `refine` pass-through, so it adds little beyond the structured fields — baseline 3.

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 resource and operation: the status of a 3D generation job, plus what it returns in each of the three states. It does not differentiate itself from the sibling `check_job`, whose name implies an almost identical capability, leaving the agent to guess which one to call.

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 an explicit trigger ("Use this when a generation tool returned status 'pending' and you need its current status or the finished model") and even a polling cadence (wait eta_seconds, or 15s if none). It never names an alternative or exclusion, notably the sibling `check_job`, so the routing decision remains ambiguous.

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 readOnly, idempotent, non-destructive, openWorld, so the description doesn't need to repeat safety. It adds real beyond-schema context: cost ('FREE'), that output includes rendered frames plus geometry stats and a plain-language reading, and that any public https .glb is accepted, not just ones made here. It stops short of describing output structure in detail, but that is largely covered by the enumeration of returns.

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

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

Front-loaded with the verb, output, and cost, and every sentence adds information about returns, use-case, or scope. Slightly redundant with two separate 'use it' imperatives near the end, which could be merged, but nothing is 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?

No output schema exists, and the description does the work of explaining what comes back: rendered images, triangle/material/texture counts, and an interpretive reading. For a read-only inspection tool with full schema coverage this is close to complete; only fine-grained return formatting is 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?

Schema coverage is 100%, with defaults and enums documented for size and views, so the schema carries the parameter burden. The description only echoes scope ('any public https .glb') and 'several angles' without adding syntax or constraint detail. 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 ('See a 3D model', 'renders the GLB from several angles and returns the frames as images') and explicitly contrasts it with mere linking. It is clearly distinguishable from siblings like mesh_forge or refine_model, which create or modify rather than inspect.

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 explicit when-to-use ('right after generating to check your own work') and a concrete workflow ('Then regenerate naming the fault you saw'), plus when to apply it ('before you hand it to the user'). It also names the alternative path implicitly – regenerate rather than inspect – leaving little to inference.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds genuinely non-obvious context: an AI art-director rewrites the prompt before generation, and results render in an inline 3D viewer. It does not disclose latency or whether the call is asynchronous, and idempotentHint=false is left unqualified despite the schema offering a 24-hour idempotency key.

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?

Output format and input modes are front-loaded, then the refinement behavior, then the usage cue. The final sentence largely restates the second ('higher quality ... prompt refined for you first'), so one clause is redundant.

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 still tells the agent the artifact type (GLB) and that it renders inline, and it explains the text-mode refinement step. The notable gap is whether a job is queued and should be polled via check_job/get_job, which the sibling list makes a realistic concern.

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

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

Schema coverage is 100%, so the schema already explains prompt, image_url, and the idempotency key in detail. The description adds only the nuance that text mode produces a 'single-subject spec', which hints at prompt constraints the schema's 'single object to model' already covers. Baseline 3 is correct when 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?

States a specific verb and resource ('Generate a textured 3D mesh (GLB)') and both input modes (text prompt or reference image URL). It positions itself as the higher-quality option versus a plainer generator but never names the sibling (forge_free), so differentiation is implied rather than explicit.

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

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

'Use this when you want a higher quality mesh from a rough prompt or reference image' gives a clear selection condition, and the mention of prompt refinement signals the cost/quality tradeoff. It stops short of naming the cheaper alternative or stating when not to use it.

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

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

Annotations cover the safety profile (destructiveHint=false, openWorldHint=false, readOnlyHint=false), so the description owes less there. It usefully discloses the turn-scoped semantics and that a view is returned that must be displayed alongside the reply, plus that emotion is auto-detected unless overridden — context 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?

Three sentences, front-loaded with the core action before the parameter and usage advice. Nearly every sentence earns its place, though the emotion clause slightly duplicates the schema description.

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 correctly compensates by explaining what comes back (a body animation for this turn) and what to do with it (show it alongside the reply). Missing only peripheral detail such as rendering timing, which is minor for this 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 description coverage is 100%, so text, emotion, and persona_id are already documented in the schema. The description largely restates those semantics ('pass the persona_id and the exact text', 'emotion is detected ... or set it explicitly') without adding new format or constraint detail, so the baseline 3 applies.

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

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

States a specific verb+resource ('Make a persona PERFORM a reply') and unpacks the effect: lip-sync, facial expression, body gesture. It clearly separates itself from the persona CRUD siblings (create_agent_persona, get_agent_persona) by describing performance rather than creation/retrieval.

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 an explicit invocation rule ('Use this whenever the persona speaks, on every turn') and names where persona_id comes from (create_agent_persona or get_agent_persona). It lacks a when-not / alternative clause, but for an always-on tool the context is already unambiguous.

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 the mutation/side-effect profile (readOnly=false, openWorld=true, destructive=false). The description adds real context beyond that: re-generation is anchored to the previous version, carries form and materials forward, produces a new lineage version that can be reverted or branched, and renders inline in the viewer. 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?

Front-loaded with the core action and example instructions, then prerequisites, then versioning behavior. Each sentence is useful, though it runs slightly long with overlapping points about lineage/version strip that could be tightened.

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 usefully describes the return: a new version plus a lineage that drives a version strip and renders inline. For a 7-param mutation tool this gives an agent everything needed to invoke it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful guidance beyond the schema by explaining why parent_prompt matters ('so the change builds on it') and that the lineage ties into version history, giving semantic weight to those optional params.

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 (refine/iterate an already-generated 3D model) and immediately distinguishes the scope: 'change a model you already generated instead of starting over.' An agent can tell this apart from generation siblings like forge_free or mesh_forge without opening the schema.

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 when-to-use: 'Use this when the user wants to change a model you already generated instead of starting over.' It also explains the pruning condition (pass glb_url and, when available, parent_prompt). It doesn't name a specific alternative tool (e.g. mesh_forge) for the starting-over case, so it falls short of the top score.

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?

Goes beyond the annotations by disclosing what actually changes (humanoid skeleton plus skin weights) and how the result is presented (rendered inline in an interactive 3D viewer), which annotations cannot convey. Weakness: the idempotency_key schema text reveals this creates a *job*, yet the description never mentions asynchronous job behavior or polling via check_job/get_job, and annotations mark idempotentHint=false despite the documented 24h dedupe.

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

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

Front-loaded with the core action and effect, no filler. However, "so it can be posed and animated" is stated twice (opening and closing sentence), making the last sentence largely redundant.

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 should explain what is returned; it only says the result is rendered inline, without saying a job reference is returned or how to retrieve it — notable given check_job and get_job are siblings. It also does not state whether the input must be humanoid-shaped for the humanoid skeleton to fit.

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 both parameters are fully documented in the schema, including the idempotency semantics. The description only adds the mild hint that the GLB URL may come from the other tools and does not explain format or size constraints beyond the schema.

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

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

States a specific verb (auto-rig) and resource (static GLB model) and spells out the concrete effect: adds a humanoid skeleton and skin weights. This clearly distinguishes it from siblings like mesh_forge (generation) and refine_model (editing), since it is the step that converts an existing GLB into a posable model.

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?

"Use this when you already have a GLB and want it rigged" gives a clear precondition and intent, and "e.g. one generated by the other tools" hints at the pipeline position. It stops short of naming explicit alternatives or exclusions (e.g. when to use mesh_forge instead), so it is clear context but not full routing 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 cover read-only/idempotent/non-destructive status, but the description adds meaningful behavior: no account required, no cost, return fields including ids and facets, and the recommended next call. This is richer than the structured hints alone.

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

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

Front-loaded with the key value proposition, then scope, return shape, and the generation-vs-catalog workflow. Every sentence contributes without repetition.

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

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

With no output schema, the description still explains the returned fields and facets, covers the no-auth/no-cost context, and provides the routing step to get_item_source. An agent has enough to select and invoke it correctly.

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

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

Schema description coverage is 83%, so most parameters are already documented. The description reinforces the kind categories and points to facets for category/tag narrowing, but does not add syntax or format detail beyond the schema.

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

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

States a specific verb and resource: search the three.ws ready-made asset catalog. It enumerates the three asset libraries and distinguishes itself from sibling generation tools by positioning catalog search as the pre-generation check.

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

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

Explicitly says when to use it ('before generating anything') and why ('if the catalog already has the prop or character, dropping it in is instant and free where generating one is not'). It also names the follow-up path to get_item_source.

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 readOnly, idempotent, non-destructive, closed-world, so safety is covered. The description adds real value beyond that: "Free, no account needed" discloses the auth requirement, and it spells out the return shape (ranked sections, page and heading title, heading-anchored url, leading snippet). It does not mention empty-result or rate-limit behavior, so not a 5.

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

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

Front-loaded with the access constraint then purpose, followed by examples, return shape, and the sibling redirect. Dense but every sentence carries distinct information; no filler.

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

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

No output schema exists, and the description compensates by enumerating what each result contains (rank, page, heading, url, snippet). With annotations covering safety and the schema covering both params, an agent has everything needed to call this correctly.

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

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

Schema coverage is 100%, so both parameters are already documented with types, bounds, and defaults. The description adds meaning for `query` by showing natural-language question examples, but says nothing about `limit` or result-count tradeoffs, so it stays at the high-coverage baseline.

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

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

Specific verb+resource ("Search the three.ws documentation") with concrete example queries that pin down the granularity of results (sections, not pages). It explicitly names the sibling it is not: "to browse ready-made 3D assets call search_catalog instead."

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 explicit when-to-use ("Use this before guessing at an API or a flow") and an explicit alternative with its selecting condition (search_catalog for ready-made assets). Nothing is left to inference about which tool to pick.

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 useful behavioral detail beyond annotations: output is GLB and renders inline in an interactive 3D viewer. But given the surrounding job tools (check_job, get_job) and the idempotency_key parameter, generation is clearly asynchronous, and the description never says the call starts a job that must be polled or how long it takes.

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

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

Front-loaded with the core capability and output format in the first sentence, which is the right structure. The final sentence largely restates the first two ('from a text description or a reference image'), making it partly redundant.

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

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

There is no output schema, and the description does explain the return artifact (GLB, inline viewer), which is good. What it omits is the job lifecycle implied by its siblings and its own idempotency_key parameter, leaving an agent unsure whether to expect a result or a job handle.

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 (prompt, image_url, idempotency_key) is already documented in the schema, so baseline 3 applies. The description adds no per-parameter meaning, such as whether prompt and image_url can be combined or which one takes precedence.

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, resource, and output artifact ('Generate a textured 3D avatar (GLB) from a text description or a reference image URL'), which is concrete and actionable. It distinguishes scope somewhat ('Best for characters and figures') but never names sibling generators like forge_avatar or mesh_forge, so the agent must infer the boundary.

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?

'Use this when the user wants a character or figure generated from a text description or a reference image' gives a clear triggering condition, and 'Best for characters and figures' implies a soft exclusion for non-character/prop requests. However, no alternative tool is named, so an agent facing forge_avatar or mesh_forge has no explicit routing rule.

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