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

With no annotations provided, the description carries full behavioral disclosure. It explains that the tool returns real signature data as JSON, lists what fields are included, describes supported query forms, and even documents the did_you_mean behavior and automatic prefix stripping. This is substantial behavioral context beyond the name and 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?

The description is well structured with an opening summary, a capabilities paragraph, query-form examples, and parameter explanations. It is long, but most sentences earn their place; the user_prompt guidance is a bit repetitive but valuable for correct invocation.

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 tool's purpose, query syntax, prefix flexibility, not-found behavior, return data shape, and parameter semantics. Given the output schema is also presentcars, an agent has everything needed to call this tool correctly in a Blender API lookup workflow.

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

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

Schema description coverage is 0%, but the description thoroughly documents both parameters. query is defined as a type, property, method, or operator path with examples, and user_prompt receives unusually precise usage guidance about verbatim quoting, chaining intent, and avoiding paraphrase. This fully compensates for the schema's lack of descriptions.

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 clear verb and resource: structured Blender RNA/API reference lookup for types, properties, functions, and operators. The query-form examples make the scope and exact capabilities concrete, and the contrast with help() output helps distinguish it from a generic introspection approach.

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 tells agents to use this instead of guessing argument names or enum valuesaine and instead of scraping text from help() output. It does not name sibling tools as alternatives, but the use conditions are clear enough for an agent to select it appropriately in most lookup scenarios.

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?

No annotations are provided, so the description carries the full burden and handles it well. It reveals the internal mechanism: creates a throwaway node in a scratch node tree, optionally applies property_overrides, reads the schema, then deletes the tree, and states that it 'never modifies anything the user can see.'

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?

Although longer than average, the description is front-loaded with purpose and organized into a clear 'Parameters:' section. The extended user_prompt guidance is necessary because that parameter is otherwise cryptic, and there is no filler or redundant restatement.

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 an output schema present and no annotations, the description covers all essential invocation context: what the tool returns conceptually, side-effect safety, parameter meanings, and when to use it. Remaining details such as exact return shape are handled by the output schema.

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

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

Schema description coverage is 0%, so the schema only provides names and types. The description adds substantial meaning: bl_idname gets concrete examples, property_overrides is explained with a mode-dependent layout example, and user_prompt receives precise quoting and repetition instructions.

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 and resource: 'Look up the property and socket schema of a Blender node type, without touching the current scene.' It also explicitly contrasts with the trial-and-error path through execute_blender_code, so the tool is clearly differentiated from its closest sibling.

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

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

It gives an explicit decision rule: 'Use this BEFORE writing code that indexes a node's sockets or sets an enum property, instead of guessing socket order or enum spelling.' It also references execute_blender_code as the alternative it saves repeated calls to, giving clear when-to-use context.

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

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

With no annotations provided, the description carries the full burden. It discloses immediate effect ('Takes effect immediately'), the irreversible nature via this tool, and the precise method to re-enable. This exceeds typical transparency for a simple toggle.

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 tightly packed sentences: the primary function, explicit triggers, and the critical limitation. All sentences earn their place, and the most important 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 opt-out tool, the description covers action, timing, triggers, and limitations. The output schema exists (though not detailed here), but for this operation the description is sufficient for an agent to invoke 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 single parameter 'user_prompt' is optional with a default and has 0% schema coverage in the description. The description does not explain its purpose or whether agents should populate it. Although the tool works without it, the lack of any guidance leaves ambiguity about how to use it.

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 action ('Turn OFF collection') against a clear resource (prompts, code, screenshots, scene data). It is unambiguous and distinct from the sibling tools, none of which deal with telemetry control.

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

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

Explicitly states when to use: 'whenever the user asks to stop data collection, opt out of telemetry, or stop sharing their data.' Also clarifies the tool's one-way nature and directs the user to the manual re-enable path, giving agents complete usage context.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It states that the tool downloads and imports into Blender and returns a success/failure message, but it does not disclose side effects such as modifying the current scene, network dependency, potential overwrites, or failure modes beyond a generic message.

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 well-structured: a clear purpose sentence, a parameter list, and a return note. The user_prompt paragraph is verbose but carries important behavioral instructions, so the slight extra length is justified.

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?

All parameters are semantically documented and an output schema exists, so the description is largely callable. However, it does not mention how to obtain an asset_id from sibling search tools, nor does it clarify scene-level effects or prerequisites, which matters given the absence of annotations.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining all five parameters with concrete examples: asset_type lists hdris/textures/models, resolution lists 1k/2k/4k, and file_format gives formats per asset type. The user_prompt parameter gets unusually detailed operational guidance.

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: 'Download and import a Polyhaven asset into Blender.' This clearly identifies what the tool does and distinguishes it from sibling tools like download_sketchfab_model and download_polypizza_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?

The main clause implies the tool is for importing Polyhaven assets into Blender, but it gives no explicit when-to-use guidance, exclusions, or alternative tool references. Among many sibling download/search tools, an agent is left to infer routing rather than being directed.

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?

With no annotations, the description carries the full behavioral burden, and it delivers: it discloses scene mutation through import, arbitrary source scale, normalization behavior, custom properties written onto root objects, and the content of the returned message. This goes well beyond the bare operation.

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 key instruction and uses a clear parameter list. The user_prompt paragraph is lengthy but justified by the verbatim-repetition requirement; a small amount of trimming would make it tighter.

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 4-parameter tool with no annotations, the description covers operational behavior, parameter semantics, and return information comprehensively. It does not discuss failure cases or network/licensing caveats, but an output schema is present and the essentials are covered.

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

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

Schema description coverage is 0%, yet the description fully compensates by explaining model_id, normalize_size, target_size with real-world examples, and the verbatim user_prompt rule. There is no ambiguity left in parameter meaning.

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

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

The description opens with a specific verb-resource pair: 'Download and import a Poly Pizza model by its ID.' It also clarifies the source (rescued Google Poly archive), which distinguishes it from the sibling Sketchfab and Hyper3D download 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 intended use is clear from the Poly Pizza naming and the reference to search_polypizza_models, and there is practical guidance on when to enable normalize_size. However, it never explicitly names alternatives or states when not to use this tool, so it stops short of full exclusion 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?

There are no annotations, so the description must carry behavioral disclosure. It does explain the key scaling behavior, the access-rights requirement, and the return message contents. However, it does not disclose that importing modifies the Blender scene, potential licensing/network issues, or what happens on failure.

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 opening line is front-loaded and the target_size examples are useful, creating an appropriately compact overall size. However, the bullet list under 'Examples:' is structurally confusing—user_prompt is mixed in as if it were a target_size example, and the small-object example is separated awkwardly from the other size examples.

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

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

Given no annotations and a sparse schema, the description covers the essential invocation context: how to identify the model, how to set scale, the access-rights prerequisite, and what the return message contains. The output schema covers return structure, so it need not restate that. The main missing piece is an explicit connection to sibling search/preview tools for obtaining the UID.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining all three parameters. target_size gains units, concrete examples, and REQUIRED status; user_prompt gets explicit verbatim-use guidance; uid is clearly defined. This goes well beyond the bare 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 states a specific action ('Download and import a Sketchfab model') on a specific resource ('by its UID'), which clearly distinguishes it from sibling search/preview tools. The verb and object are unambiguous and do not require additional inference.

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

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

The description implies the tool is used after obtaining a UID and emphasizes the need for download access rights, but it does not explicitly say 'use this after search_sketchfab_models' or provide when-not-to-use guidance. No exclusions or alternatives are mentioned, so the usage context is only implicit.

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?

With no annotations, the description carries the full behavioral burden, but it only says code is executed. It does not disclose side effects, potential for destructive scene changes, undo behavior, permissions, or error handling—critical context for arbitrary code execution.

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 purpose is front-loaded in a single clear sentence, and the parameter list is compact. The user_prompt guidance is long but earns its place because it enforces a non-obvious contract about preserving user intent.

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 high-complexity arbitrary-code tool with no annotations, key context is missing: execution environment, access to bpy, return values, failure behavior, and safety/undo implications. The user_prompt detail is helpful, but the description is not sufficient for safe and correct 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?

Schema description coverage is 0%, so the description must compensate. The user_prompt parameter is richly specified (verbatim quotes, repeat unchanged, never substitute), adding real meaning. The code parameter is only described as 'The Python code to execute,' adding little beyond the schema's type.

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 action ('Execute arbitrary Python code') and the target environment ('in Blender'), making it clear what the tool does. It is distinct from sibling tools like get_scene_info or bpy_api_lookup, which are targeted operations rather than general script execution.

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 no guidance about when to use this tool versus specialized siblings, such as preferring get_object_info for read-only queries or using dedicated asset tools. The 'step-by-step' advice is about execution style, not tool selection.

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

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

With no annotations provided, the description carries the full burden. It discloses useful behaviors such as parent folder creation, selection_only precedence over object_names, and the effect of apply_modifiers. However, it does not state whether the operation modifies the Blender scene or overwrites existing files, leaving some behavioral gaps.

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: a single purpose sentence followed by a parameter list. All information is relevant and front-loaded, with no redundant phrasing.

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

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

The description covers all parameters, mentions the return JSON fields, and gives practical usage tips. It is sufficient for an agent to call the tool correctly, though it omits edge-case behavior like file overwrites or error handling. Given the output schema exists, this is nearly 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 description provides detailed explanations for all six parameters beyond their schema titles, including defaults, precedence rules, and usage advice (e.g., 'false for rigged / shape-key meshes'), fully compensating for the 0% schema description coverage.

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

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

The description clearly states the tool exports a scene, selection, or named objects to GLB or FBX files, specifying the exact resource and action. This distinguishes it from sibling tools like set_texture or get_viewport_screenshot, which have different purposes.

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 parameter-level guidance (e.g., apply_modifiers for rigged meshes, selection_only precedence) but does not explicitly state when to use this tool versus alternatives or when not to use it. Usage is implied by the export purpose, but no explicit when/when-not guidance is given.

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

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

With no annotations provided, the description carries the full burden. It discloses the asynchronous nature via job_id and status transitions, mentions built-in materials, and describes error handling. This is more transparent than typical tool descriptions, though it does not cover permission requirements or rate limits.

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 well-structured: the purpose is stated first, followed by a parameter breakdown and return information. The parameter details are necessary given the schema gap, so the length is justified and not wasteful.

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 generation, import, materials, async status flow, and error handling. It does not mention prerequisites like add-on status, but the sibling tools for checking status exist. The output schema exists, so detailed return structure is not needed. Overall, it is complete for the tool's complexity.

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

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

The schema has 0% coverage, but the description provides detailed explanations for all three parameters, including optionality, language constraints for text_prompt, URL format for input_image_url, and the critical behavioral instruction for user_prompt to quote verbatim. This fully compensates for the schema gap.

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 (generate), the resource (3D asset using Hunyuan3D), and the additional action of importing into Blender. It distinguishes from sibling tools by explicitly naming Hunyuan3D, unlike generate_hyper3d_model_via_text which targets Hyper3D.

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 that either a text prompt, image URL, or both can be provided, which is a usage condition. However, it does not explicitly state when NOT to use this tool or point to alternatives (e.g., for Hyper3D models), leaving the differentiation to the tool name 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?

With no annotations, the description carries the full burden. It discloses that the asset has built-in materials, the model is normalized in size, and the tool imports into Blender. However, it does not mention that generation may be asynchronous (given the sibling poll_rodin_job_status) or any prerequisites (e.g., addon status). The mention of mode-dependent requirements is useful but not exhaustive.

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 well-structured and front-loaded with the core purpose, followed by essential behavioral notes and a detailed parameter list. Every sentence adds value, especially given the low schema coverage. There is no fluff or 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?

While the parameter semantics are strong, the description omits the asynchronous workflow: it doesn't mention that generation might require polling via poll_rodin_job_status, nor does it explain how to determine the current Rodin mode. The output is described only as a success/failure message, which is acceptable given the output schema exists, but the overall workflow is incomplete for a complex multi-step process.

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

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

Schema coverage is 0%, so the description must compensate, and it does thoroughly. Each parameter is explained with concrete details: absolute paths vs URLs, wrapping single inputs in lists, bbox_condition format and meaning, and the user_prompt rule about verbatim quoting and repetition. This adds substantial meaning beyond the raw 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's purpose: generating a 3D asset from images via Hyper3D and importing it into Blender. It distinguishes itself from the sibling generate_hyper3d_model_via_text by explicitly mentioning 'via images', making the verb and resource 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 provides clear guidance on parameter selection (only one of input_image_paths/input_image_urls should be given, depending on Rodin mode), but it does not explicitly contrast with the text-based alternative or state when to choose this tool over it. The purpose statement implies usage, but exclusions and alternatives are not named.

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?

With no annotations provided, the description carries most of the transparency burden. It usefully discloses built-in materials, normalized size, the import into Blender, and a success/failure message, but it omits possible async behavior, runtime expectations, scene side effects, and prerequisites such as add-on or service status.

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 opening sentence front-loads the core behavior, the material and normalization notes are short and useful, and the parameter list is direct. There is no filler or unnecessary repetition of schema defaults.

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 gives enough for a typical invocation: input semantics, optional parameters, output behavior, and post-generation asset characteristics. It falls short only by not clarifying whether generation is asynchronous, whether user_prompt is truly optional despite its schema default, and how the import interacts with the existing Blender scene.

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 0%, but the description fully compensates by explaining text_prompt language and content, the exact list shape and length-3 meaning of bbox_condition, and the nuanced verbatim reuse rule for user_prompt. Every parameter gets actionable guidance beyond its schema type or default.

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

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

The description clearly states the action and resource: it generates a 3D asset using Hyper3D from a description and imports it into Blender. This also differentiates the tool from image-based generation and Hunyuan siblings by emphasizing text-prompt input.

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 intended use is implied: call this when the user wants a 3D asset generated from a text description and imported into Blender. However, it never names alternatives like generate_hyper3d_model_via_images or generate_hunyuan3d_model, nor does it state when not to use this tool in favor of them.

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?

With no annotations, the description carries the full disclosure burden. It states that an outdated addon triggers update instructions, tells the user to restart/re-enable, and explains that telemetry_consent can be on, off, or null if Blender cannot be reached. It stops short of labeling the operation as read-only, but the wording implies a check with no mutation.

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 compact sentences front-load the core purpose before adding update instructions and telemetry guidance. Every sentence adds distinct 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 one-parameter optional tool with an output schema, the description covers the version check, update path, and telemetry edge case. The only notable gap is the undocumented user_prompt parameter, but its optional nature lessens the impact.

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

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

Schema description coverage is 0%, and the description never mentions the single user_prompt parameter. An agent gets no guidance on what to supply, whether it shapes the request, or how it interacts with version/telemetry checks.

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 opens with a precise action and resource: checking whether the connected Blender addon matches the MCP server version. It also introduces telemetry_consent, which separates it from the other provider-status siblings such as get_polyhaven_status or get_hyper3d_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 gives an explicit use case: 'Use it to answer telemetry status questions.' It does not provide when-not-to-use directions or name alternatives, but the context is clear enough for an agent to select this over unrelated status 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?

With no annotations provided, the description bears the full burden of behavioral disclosure. It states the tool returns a message about availability, which implies read-only behavior, but it does not explicitly confirm no side effects, mention possible errors, or describe what happens if the integration is disabled. This is adequate but minimal for a simple status check.

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, two clear sentences with no extraneous words. It front-loads the core purpose and states the return type, making it efficient and easy to parse.

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

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

While the tool is simple, the presence of an undocumented user_prompt parameter creates a significant gap. The description does not explain the parameter's role or provide enough context for correct invocation. Additionally, the description only vaguely mentions 'a message' without detailing the output structure, even though an output schema exists. The overall completeness is lacking for a tool with an unexplained parameter.

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 includes one parameter, user_prompt, with a default empty string, and schema description coverage is 0%. The description does not mention this parameter at all, leaving it completely unexplained. Why a status check needs a user prompt is unclear, and the agent has no information on how to fill or use it. The description fails to compensate for the schema's lack of 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 checks whether Hunyuan3D integration is enabled in Blender, naming the specific integration and distinguishing it from sibling status tools like get_hyper3d_status and get_sketchfab_status. The verb 'check' and resource are explicit, leaving no ambiguity about the tool's function.

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 provided on when to use this tool versus alternatives (e.g., before generating a Hunyuan3D model) or when not to use it. The description implies a status check but does not state any prerequisites, exclusions, or conditions for selection, leaving the agent to infer usage from context.

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

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

No annotations are provided, so the description carries the burden of disclosing behavior. 'Check if ... enabled' strongly implies a read-only status check and it says a message is returned, but it does not explicitly state that it is side-effect-free or clarify whether it checks local Blender state, an external service, or something else.

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 short sentences with no filler. It front-loads the verb and resource, and the second sentence adds the return behavior 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 output schema presumably covers the return message, so the main gap is the undocumented user_prompt parameter. Combined with the absence of annotation context and any routing guidance among the many similar status tools, the description is not fully complete for correct 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 single parameter user_prompt has 0% schema description coverage and is not mentioned in the description at all. The agent has no way to know what this parameter means, whether to pass it, or how it affects the status result.

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

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

The description uses a specific verb ('check') with a specific resource ('Hyper3D Rodin integration in Blender') and names the observable outcome ('returns a message indicating whether features are available'). This clearly differentiates it from siblings like get_hunyuan3d_status or get_polyhaven_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 implies this tool should be used before relying on Hyper3D Rodin features, but it never explicitly says when to use it versus the other status tools or the Hyper3D generation tools. There is no when-not guidance or mention of 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?

No annotations are provided, so the description must disclose behavior. It only states 'get detailed information' which implies read-only, but it does not confirm non-destructiveness, describe the return format, or mention error handling (e.g., missing object). The agent is left without safety or side-effect information.

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 main purpose is front-loaded in a single clear sentence. The parameter list is necessary, though the user_prompt explanation is verbose. Overall, it is efficient and structured for quick scanning, with no 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?

The output schema (not shown but indicated) covers return values, so that is not a gap. However, the description omits prerequisites (e.g., object must exist), potential errors, and side-effect guarantees. For a simple read tool, it is acceptable but not fully complete.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does: object_name is defined as 'the name of the object to get information about', and user_prompt receives extensive guidance on quoting verbatim and linking intent. This fully compensates for the schema's lack of descriptions.

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 (get), the resource (specific object), and the context (Blender scene). It is distinct from sibling tools like get_scene_info (scene-level) and get_viewport_screenshot (visual), so an agent can easily select it for object-level queries.

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

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

The description implies when to use this tool (when you need object information) but provides no explicit guidance on alternatives or exclusions. It does not mention, for example, using get_scene_info for scene-wide data or execute_blender_code for custom queries. The usage context is clear but not explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'Get a list' but does not explicitly confirm the operation is read-only, nor does it mention authentication, rate limits, error behavior, or any side effects. The user_prompt parameter is described as needing to be passed on every call, but the description does not explain why the tool requires it or what happens if it is omitted, leaving the agent without full insight into the tool's 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 opens with a clear, concise purpose statement, but the parameter descriptions, especially for user_prompt, are verbose and repetitive (e.g., 'Pass the same goal on every call', 'Never substitute your own sub-goal', 'repeat their previous words unchanged' – these overlap in meaning). The length could be reduced without losing essential information, making it less concise than ideal.

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 and the presence of an output schema (which defines the return structure), the description does not need to explain return values. However, it omits any mention of prerequisites such as an active connection to Polyhaven or authentication, and it does not clarify why the user_prompt parameter is necessary for this specific operation. While an agent can likely call it correctly based on the given information, the description leaves 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?

The schema has no descriptions and 0% coverage, so the description must compensate. It does: for asset_type, it lists the valid values (hdris, textures, models, all) which are not in the schema as an enum; for user_prompt, it provides detailed usage instructions (verbatim quoting, passing the same goal each call, avoiding paraphrase). This adds meaningful semantic value beyond the schema's defaults, though the user_prompt explanation is more about usage than its semantic role.

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 'Get a list of categories for a specific asset type on Polyhaven.' This clearly identifies the verb (get), the resource (categories list), and the context (specific asset type, Polyhaven). It is distinct from sibling tools like search_polyhaven_assets (searches assets) and download_polyhaven_asset (downloads assets), so an agent can easily differentiate it.

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 explicit guidance on when to use this tool versus alternatives. It does not mention any prerequisites, typical scenarios, or cases where another tool would be more appropriate. The agent must infer usage from the purpose alone, with no exclusions or alternatives named.

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?

With no annotations provided, the description carries the burden of behavioral disclosure. It frames the tool as a read-only status check and mentions the return message, but it does not explicitly state side effects, authorization requirements, or failure behavior. The simple nature of the check partially compensates.

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 with no filler. The main action and return value are front-loaded, making it easy for an agent to quickly understand the tool.

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

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

For a simple status-check tool with an output schema, the description adequately covers the core purpose and result. However, it omits any guidance on the `user_prompt` parameter and does not differentiate this tool from the many sibling integration-status tools, 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?

The input schema has one optional parameter, `user_prompt`, with 0% schema description coverage. The description does not mention this parameter at all, leaving its purpose and expected content completely unexplained. Since the parameter is optional and has an empty default, the impact is limited but still a real gap.

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 specific action ('Check if PolyHaven integration is enabled in Blender') and the expected return ('a message indicating whether PolyHaven features are available'). It is unambiguous and distinguishable from sibling status tools by name and resource.

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 intended use is implied: call this tool when you need to know whether PolyHaven is enabled in Blender. However, no explicit when-to-use, when-not-to-use, or alternatives among the many sibling status tools are mentioned.

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

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

There are no annotations, so the description carries the burden. 'Check if' and 'Returns a message' convey a read-only retrieval behavior without obvious side effects. It does not add richer behavioral detail beyond availability, but for a simple status check it is minimally transparent.

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 short sentences carry the key purpose and return behavior with little redundancy. It is appropriately concise, though the second sentence is somewhat generic.

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 status check with no required parameters and an output schema, the description is nearly sufficient. Its main gap is the unexplained user_prompt parameter and the lack of sibling differentiation, but it still likely allows a correct call.

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

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

The schema has one parameter, user_prompt, with 0% schema description coverage, and the description never mentions it. The agent is given no hint of what the parameter does or why it exists, so the description adds no value for 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 states a specific verb ('Check if') and resource ('Poly Pizza integration in Blender'), making the tool's function immediately clear. The resource name distinguishes it from sibling status tools like get_polyhaven_status or get_addon_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 implies when to use it: when the agent needs to determine whether Poly Pizza features are available in Blender. However, it offers no explicit guidance for choosing among the many sibling status tools or any exclusions.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. The verb 'Get' implies a read operation, but the description never explicitly states that it does not modify the scene, nor does it describe side effects, failure modes, or what 'detailed information' includes. This is a meaningful gap for a tool with no annotation safety 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 opens with a clear purpose sentence and then provides parameter guidance. The parameter paragraph is somewhat wordy but each instruction is relevant, and the structure is easy to parse. It earns its length because the schema itself provides no parameter documentation.

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, has one well-documented parameter, and an output schema exists, so return-value detail is not required from the description. However, it lacks usage guidance and explicit behavioral transparency, which prevents the description from being fully self-contained. Overall it is adequate but has clear 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?

The schema only defines the parameter with no description, and the description fully compensates. It clearly specifies that user_prompt must be quoted verbatim, not paraphrased, reused across multi-step tasks, and never replaced with sub-goals or status text. This is rich, actionable guidance beyond the schema.

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

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

The description states a specific verb ('Get') and resource ('detailed information about the current Blender scene'), making the tool's purpose clear. It does not explicitly distinguish itself from sibling tools like get_object_info, but the scene-level resource scoping makes the distinction inferable.

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 alternatives such as get_object_info, get_viewport_screenshot, or export_scene. There is no mention of appropriate contexts, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name.

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 are absent, so the description carries the burden of behavioral disclosure. It explains that the tool returns the model's thumbnail as an Image, which is useful given there is no output schema. The read-only nature is implied by "preview" and "Get", and the description appropriately avoids claiming any download or mutation 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 well-structured and front-loaded with the core purpose. The user_prompt explanation is long but justifies its length by encoding critical agent behavior. The parameter list and return-value statement are clean, with only minor redundancy between "preview thumbnail" and "Returns the model's thumbnail."

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 preview tool with no annotations and no output schema, the description supplies everything needed: how to obtain uid, how to handle user_prompt, what the tool returns, and the intended use case. No missing information would prevent an agent from calling 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?

Schema description coverage is 0%, so the description must fully explain the parameters. It does: uid is identified as the Sketchfab model UID obtained from search_sketchfab_models, and user_prompt receives extensive, precise instructions about quoting verbatim and preserving intent across multi-step tasks. This adds substantial meaning beyond the bare schema fields.

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 opens with a specific verb and resource: "Get a preview thumbnail of a Sketchfab model by its UID." It clearly distinguishes this tool from the nearby downloadable/search siblings by framing it as a preview step before downloading. The purpose is unambiguous and immediately actionable.

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 states when to use it: "Use this to visually confirm a model before downloading." This gives a clear use context without naming a specific alternative tool, but the sibling list makes the intended distinction obvious enough. It lacks explicit when-not-to-use wording, but the guidance is still 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 says the tool performs a check and returns a message, which implies a non-mutating status probe. However, there are no annotations, so the description carries the full transparency burden; it does not explicitly state that there are no side effects, no authentication requirements, or no network modifications. This is a moderate gap for such a simple status 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?

The description is two short, declarative sentences. It front-loads the primary action and immediately states the result, with no filler, repetition, or unnecessary detail. Every sentence contributes 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 no-required-parameter status check with an output schema present, the description is nearly complete: an agent can call it and understand the general response. The missing note about the optional user_prompt parameter and the lack of sibling routing guidance prevent a perfect score, but the omission is not critical for basic 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 schema has one optional parameter, user_prompt, with zero schema description coverage and no parameter documentation. The tool description never mentions this parameter or explains whether/how it affects the returned status. Although the parameter is optional with a default, the agent receives no guidance about whether to supply it or what it controls.

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 opens with a specific verb and resource: 'Check if Sketchfab integration is enabled in Blender.' It then clarifies the output (a message indicating availability), making the tool's purpose unambiguous and distinct from sibling status tools for other services.

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

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

The description directly states when this tool is relevant: when you need to determine whether Sketchfab features are available in Blender. It does not explicitly mention sibling alternatives or exclusions, so it stops short of a 5, but the usage context is clear and not merely hidden in the name.

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?

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It discloses that the return value is an Image, but it does not state whether the operation is read-only, what side effects (if any) occur, whether a scene must be open, or any limitations on capture. The detailed user_prompt instructions concern parameter usage, not tool behavior. This is insufficient for a tool with no annotation coverage.

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

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

The first sentence is clear and front-loaded, and the parameter list is structured. However, the user_prompt paragraph is verbose and contains repetitive admonitions ('do not paraphrase', 'Never substitute', 'repeat their previous words unchanged'), which could be condensed. It is not overly long, but it is not optimally concise.

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 two-parameter screenshot tool with no output schema, the description covers the return type and parameter meanings. But it omits any usage context, prerequisites (e.g., Blender must be open), or error scenarios. The default-value discrepancy between description and schema also leaves agents with conflicting information, reducing 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?

The description adds meaning beyond the schema by explaining max_size as the maximum pixel dimension and giving a default, and by providing extensive rules for user_prompt. However, there is a factual contradiction: the description states a default of 800 while the schema declares a default of 1000. That inconsistency undermines the reliability of the parameter documentation, so the added value is offset.

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 ('Capture'), resource ('screenshot of the current Blender 3D viewport'), and clearly defines the tool's function. Among the sibling tools, none offer a similar screenshot capability, so it is easily distinguishable. This meets the highest standard for purpose clarity.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The function implies usage for capturing the viewport, but there is no context such as 'use when visual feedback is needed' or comparison to export_scene or record_trajectory_feedback. This leaves the agent to infer when it should be invoked.

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?

With no annotations provided, the description carries the full burden. It discloses that it returns a success indicator ('Return if the asset has been imported successfully') and enforces a parameter exclusivity constraint. However, it does not describe side effects (e.g., scene modifications), failure modes, or necessary preconditions, leaving some ambiguity for a mutation-like operation.

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, structured with a parameters list and a note on exclusivity. Every sentence provides value: purpose, parameter explanations, and usage constraint. No fluff 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?

For a simple 3-parameter tool with no output schema, the description covers the essential aspects: target resource, when to use, parameter semantics, and return status. It could be more explicit about prerequisites (e.g., an active scene) but is sufficiently complete given the tool's 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 coverage is 0%, so the description must compensate, and it does thoroughly. It explains 'name' as the object name in scene, and crucially distinguishes 'task_uuid' (for MAIN_SITE mode) from 'request_id' (for FAL_AI mode), including the conditional rule that only one should be provided. This adds significant meaning beyond the bare 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 verb 'Import' and the resource 'asset generated by Hyper3D Rodin after the generation task is completed'. It distinguishes from the sibling 'import_generated_asset_hunyuan' by specifying 'Hyper3D Rodin', making the purpose unambiguous.

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

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

The description explains when to use the tool ('after the generation task is completed') and provides explicit usage guidance on parameter selection: 'Only give one of {task_uuid, request_id} based on the Hyper3D Rodin Mode!'. It does not explicitly mention alternatives or when not to use, but the context is clear enough for an agent to select correctly.

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?

No annotations are provided, so the description carries the burden. It discloses the import action and the return value ('Return if the asset has been imported successfully'), but it doesn't mention side effects like whether the asset replaces an existing object, whether it requires a prior generation task, or any failure modes. The return statement is vague ('if' could mean a boolean or an error).

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 compact and front-loaded with the main purpose, followed by parameter details and a return note. Every sentence earns its place, though the 'Return if...' line is slightly awkward and could be clearer.

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 2-parameter tool with no output schema and no annotations, the description covers the core usage: what to pass and what to expect. However, it lacks context on prerequisites (e.g., must have a completed Hunyuan3D generation task), error handling, and what 'imported successfully' means in terms of return value. The sibling 'import_generated_asset' suggests there may be a generic version, and the description doesn't clarify why an agent would choose this Hunyuan-specific one.

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

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

Schema description coverage is 0%, so the description must compensate. It does: it explains 'name' is the object name in the scene and 'zip_file_url' is a model URL from ResultFile3Ds with format preferences. This adds meaning beyond the bare schema titles, though it could be more explicit about the exact format expected for 'name'.

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 imports an asset generated by Hunyuan3D after generation completes, with a specific verb ('Import') and resource ('asset generated by Hunyuan3D'). It distinguishes itself from the sibling 'import_generated_asset' by naming the Hunyuan3D source, though it doesn't explicitly contrast with that sibling.

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

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

The description gives clear context: use after the generation task is completed, and it specifies the zip_file_url should come from ResultFile3Ds, preferring .glb URLs with .zip/.obj as fallback. It doesn't explicitly say when not to use it or name alternatives, but the context is sufficient for an agent to select it appropriately among siblings.

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?

With no annotations provided, the description fully explains the polling behavior: statuses RUN/DONE/failure, and that a DONE status yields ResultFile3Ds with download URLs. It also gives asset-selection guidance (.glb preferred). It does not mention rate limits or auth, but the operation is inherently a read-only check, and the behavior is well-disclosed.

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

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

The description is organized with a clear purpose statement, parameter guidance, return semantics, and asset-selection advice. It is somewhat longer than strictly necessary, but every sentence adds value and it is front-loaded with the core 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?

For a polling tool with no output schema, the description covers everything an agent needs: how to identify completion, the meaning of each status, the return payload shape, and the preferred URL type. The lack of an output schema is fully compensated.

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 only a title and default for job_id, with 0% coverage. The description compensates by stating the parameter comes from the generate model step, which is essential context for supplying the correct value. This fully clarifies an otherwise opaque 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 states a specific verb ('Check if the Hunyuan3D generation task is completed') and resource (Hunyuan3D job). It clearly differentiates from the sibling poll_rodin_job_status by name and content, and ties to generate_hunyuan3d_model via the referenced job_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?

Provides clear context: the job_id comes from the generation step and it is a polling API to be used until a final status. It does not explicitly say when NOT to use it versus poll_rodin_job_status, but the vendor-specific wording and name make the distinction obvious.

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?

With no annotations, the description carries the full behavioral disclosure burden. It discloses mode-specific statuses, progress states, failure conditions, and terminal states: 'Done', 'Canceled', 'COMPLETED', 'IN_PROGRESS', and 'IN_QUEUE'. It does not describe exact response shape or polling timeout/block behavior, but the core decision logic is clear.

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 well organized into two mode sections with clear parameter and status explanations. It is still reasonably tight, though the 'polling API, so only proceed' caution is repeated in both sections, which slightly reduces conciseness.

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

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

Given the absence of annotations and output schema, the description covers the important status logic, failure conditions, and decision rule with enough clarity for an agent. It is slightly incomplete because it does not differentiate itself from the sibling get_hyper3d_status tool or describe the response structures in more 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 contains two arbitrary string fields with no descriptions and 0% schema coverage. The description compensates by explaining that subscription_key belongs to MAIN_SITE mode and request_id belongs to FAL_AI mode, both obtained from the generate step. It still does not explicitly state that exactly one parameter is required depending on mode.

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 opens with a specific verb-resource pair: checking whether the Hyper3D Rodin generation task is completed. It clearly separates behavior across MAIN_SITE and FAL_AI modes, which makes the tool's role in the generation pipeline obvious and distinguishes it from sibling generation/import 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?

It gives useful usage context: it is a polling API, should be called when checking generation status, and should only proceed when terminal statuses are observed. However, it does not explicitly name alternatives such as get_hyper3d_status or describe when this tool is not 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It adds useful context such as the default step_index and the relationship between correction_text and correction feedback. However, it does not mention whether feedback is appended or overwritten, whether a prior captured step is required, or any side effects beyond recording.

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 compact and purpose-driven. It opens with a one-sentence definition, then uses a clean parameter list that adds value without repeating the schema verbatim.

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 and the presence of an output schema, the description is nearly complete: all parameters are covered and defaults are stated. Minor gaps are minor, such as whether feedback can be re-recorded or edited for the same step, and the implicit prerequisite of an existing captured trajectory step.

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

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

Schema description coverage is 0%, but the description fully compensates by explaining every parameter: the allowed feedback values, the optional correction_text, the 0-based step_index with its default, and the user_prompt context. This is exactly the kind of semantic detail the schema lacks.

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 clear verb-object structure: 'Record evaluation feedback for a captured trajectory step.' This clearly identifies the resource and action, and the trajectory-specific language sets it apart from the surrounding Blender/modeling tools. It does not explicitly differentiate from a sibling, but no sibling is close enough to require that.

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 practical usage context: feedback can be one of four values, correction_text is especially relevant for corrections, and step_index defaults to the last recorded step. It does not explicitly state when not to use the tool or name alternatives, but the context is clear and no alternative tool is apparent.

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?

With no annotations, the description carries the behavioral burden. It discloses the read/search nature and return content ('list of matching assets with basic information'), and it adds specialized user_prompt persistence behavior that the schema does not convey. It omits operational details like network dependencies, result limits, or error behavior, but those are less critical for a read-only search 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?

The description is front-loaded with a one-sentence purpose, followed by a scannable bullet list of parameters. The user_prompt guidance is longer than the other bullets, but every sentence serves a clear guardrail purpose and is not filler, so the structure still earns its place.

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

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

For a three-parameter, zero-required search tool with an output schema, the description plus schema gives enough to call correctly: allowed asset types, category filtering format, prompt semantics, and the nature of the result. The only notable gap is the lack of explicit routing guidance against siblings like get_polyhaven_categories, but that gap is already captured in the usage_guidelines dimension.

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

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

Schema description coverage is 0%, so the description must compensate, and it does fully cover all three parameters: asset_type enumerates its allowed values, categories defines its format, and user_prompt receives detailed behavioral semantics. This goes well beyond the bare schema and prevents invocation errors.

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?

Opens with a specific verb and resource ('Search for assets on Polyhaven'), and the filtering clause distinguishes it from sibling download/category tools like download_polyhaven_asset and get_polyhaven_categories. The first sentence alone tells an agent exactly what the tool does.

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

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

The description implies a search workflow ('Returns a list of matching assets') but never explicitly says when to choose this over get_polyhaven_categories, download_polyhaven_asset, or search_sketchfab_models. There are no exclusion criteria or alternative routes, so usage is inferred from tool name and siblings 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?

No annotations are provided, and the description takes on the disclosure burden. It reveals output behavior ('Returns a formatted list... with licence and triangle count on every row') and constraint context (API caps at 32). It doesn't mention side effects, but a search tool's read-only nature is strongly implied by the verb and output description.

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 structure is clear: a one-line summary, a per-parameter list, then expected output. The user_prompt entry is unusually long, but it encodes an important quoting/consistency rule that would otherwise be lost; no sentence 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?

For a tool with six optional parameters and no annotation help, the description covers the input constraints, defaults, API cap, output contents, and the purpose of the return format ('so a low-poly, permissively licensed asset can be picked without a second call'). With an output schema present, this 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 has 0% description coverage, and the description fully compensates by explaining every parameter: query emptiness rule, category examples, exact licence values with credit meaning, animated default, limit default and API cap, and the special verbatim user_prompt rule. This adds substantial meaning beyond the bare name/type 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 opening line uses a specific verb and resource ('Search for models on Poly Pizza') and immediately distinguishes the tool from sibling searches for other libraries like search_polyhaven_assets and search_sketchfab_models. It clearly covers search/filtering on Poly Pizza rather than downloading or status checking.

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 states the search supports optional filtering and details when query may be empty ('May be left empty if at least one filter is given'), and gives concrete filter semantics (licence values, animated default, limit cap). It does not explicitly name alternatives or state when not to use it, so it falls 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It says the tool 'searches' and 'returns a formatted list,' but it does not state that this is an external read-only API call, mention network dependency, failure modes, or whether local state is untouched. For an unannotated tool, this is a meaningful transparency gap.

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 purpose is front-loaded and the parameter list is organized, but the user_prompt instruction is repetitive and longer than necessary, restating the same 'do not paraphrase' guidance multiple times. The description is adequate in length but could be tightened without losing meaning.

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 presence of an output schema and a clear parameter list, the description is mostly complete for correct invocation. It covers the query, filters, defaults, and return shape. The main missing context is external-service behavior and failure handling, but for a search tool this does not severely block correct 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 description coverage is 0%, but the description compensates by explaining all five parameters: query text, comma-separated categories, count with default, downloadable filter, and the unusual user_prompt behavior. This goes well beyond the bare property names in the schema, though it could be stronger with examples or constraints.

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 opens with a specific verb and resource: 'Search for models on Sketchfab.' This clearly distinguishes it from sibling tools targeting other providers such as Poly Haven or Poly Pizza, and from Sketchfab operations like preview or download. Optional filtering adds scope without ambiguity.

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 makes the usage context clear: use this when the user wants to find Sketchfab models, and optionally filter them. It does not explicitly name alternatives like download_sketchfab_model or search_polyhaven_assets, but the Sketchfab-specific phrasing and search emphasis provide sufficient context for selection.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It states the action and the return message but does not disclose potential side effects (e.g., overriding existing textures, modifying object materials), any permission requirements, or reversibility. The user_prompt instruction is about agent behavior, not the tool's own behavior, so it does not improve transparency.

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

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

The structure is clear: a lead sentence stating purpose, followed by a parameter list. However, the user_prompt explanation is verbose and repeats the same instruction multiple times, which could be condensed. While every sentence serves a purpose, the wordiness detracts from conciseness.

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

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

The description covers the essential contextual information: the precondition (texture must be downloaded), the required parameters, and the return behavior. It does not mention potential edge cases like invalid object types or failed texture application, but given the presence of an output schema (not shown) and the deliberate user_prompt guidance, it is adequately complete for an agent to invoke this 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 description fully compensates for the 0% schema description coverage by explaining each parameter: object_name is the target object, texture_id must be a downloaded Polyhaven texture, and user_prompt is given an extensive, unambiguous explanation (including verbatim quoting and repetition rules). This adds substantial meaning beyond the bare 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 states a specific action ('Apply') and a clear resource (a previously downloaded Polyhaven texture) on an object. It distinguishes itself from sibling tools like download_polyhaven_asset (downloads) and search_polyhaven_assets (searches), but does not elaborate on the nuances of 'apply' (e.g., whether it sets a material or texture slot), leaving slight ambiguity.

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

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

The description implies the tool should be used after a texture has been downloaded ('previously downloaded'), establishing a clear precondition. However, it does not explicitly mention alternatives or when not to use this tool, nor does it contrast with other texture-related operations. The user_prompt guidance pertains to a parameter, not overall usage context.

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