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 signals a state-changing operation by saying 'download and import,' but it does not explain side effects, required network access, how the import interacts with the current Blender scene, or whether the operation blocks.

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

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

The description is a single sentence with no filler, front-loading the core action and target. It is concise and clear, though it lacks supporting context that would make it more informative.

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

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

With no output schema and no annotations, the description should explain expected outcomes, errors, and behavioral effects. It does not mention return values, where the asset is saved, what happens on failure, or how long the operation might take, leaving significant gaps for a mutating tool.

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

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

The input schema provides a description for all four properties, including allowed values for asset_type, resolution, and file_format. The description adds no parameter-level detail, but at 100% schema description coverage, the baseline of 3 applies.

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

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

The description uses specific verbs ('download' and 'import'), a clear resource ('PolyHaven asset'), and a clear destination ('Blender'). It also distinguishes itself from siblings that operate on Sketchfab, Hyper3D, or Hunyuan3D assets.

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

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

No guidance is given on when to use this tool versus alternatives like search_polyhaven_assets, import_generated_asset, or download_sketchfab_model. There is no mention of prerequisites, such as needing to search for the asset first or knowing its ID.

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 names the action but does not reveal whether the download is asynchronous (especially relevant given status-polling siblings), what changes occur in the scene, 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 description is eight words with no filler, and the core identifier (UID) is front-loaded. Every word contributes 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?

For a single-parameter tool, this is minimally sufficient to make a call, but the lack of any outcome or async guidance—especially when sibling status tools exist—leaves the agent uncertain about what happens after invocation. Some behavioral context is missing.

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

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

Schema coverage is 100%, and the schema already fully describes the uid parameter. The description adds no new semantic detail beyond restating 'by UID', so it meets the baseline but does not exceed 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 verb ('Download and import'), the resource ('Sketchfab model'), and the identifying input ('UID'). It clearly distinguishes this from sibling tools like download_polyhaven_asset and search_sketchfab_models.

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

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

The description implies usage when a Sketchfab model UID is already known, which pairs naturally with search_sketchfab_models, but it never explicitly states when to prefer this over alternatives or mentions any exclusions. The context is clear but under-specified.

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 the full burden of behavioral disclosure. It reveals nothing about side effects, persistence of changes, undo behavior, safety risks, Blender context availability, or whether arbitrary code can mutate scenes in irreversible ways.

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 short and front-loaded with the core purpose. The second sentence is mildly useful advice, but it is vague and does not add substance. Still, there is no redundant or bloated 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?

For an arbitrary code execution tool inside Blender, the description is incomplete. It does not mention return values, how results are communicated back, whether bpy is available, how errors are reported, or what execution context the code runs in. These are critical for an agent to reliably call the tool.

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

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

The schema provides 100% coverage of the single parameter 'code' with the description 'Python code to execute'. The tool description adds no further meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: executing Python code in Blender. This is a specific verb-resource pair and is distinct from all sibling tools, which concern asset status, searches, downloads, and generation.

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 only a vague operational tip—'Break complex operations into smaller steps'—but does not explain when to choose this tool over the Blender-specific sibling tools, when not to use it, or what kinds of operations are appropriate for direct code execution.

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 and no output schema, the description carries the full burden of behavioral disclosure, but it only states the operation type. It does not reveal whether the generation is asynchronous, whether it returns a job ID, whether the result must be polled and imported, or what happens if no input is provided. The sibling names strongly imply an async pipeline, but the description leaves this entirely to inference.

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

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

A single 10-word sentence that front-loads the verb and packs the key differentiators (engine, input modes). No filler or redundancy. It loses a point only because it is so terse that it omits behavioral context that the score elsewhere penalizes.

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 generation tool with no annotations, no output schema, and zero required parameters, one sentence is not enough. The sibling ecosystem reveals a needed workflow (generate → poll → import) that the description never hints at, and an agent would not know how to obtain or consume the result. This is a meaningful completeness gap 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?

Schema coverage is 100%, so the baseline is 3, but the description misses a critical semantic point: it says 'from text or image' without clarifying that at least one input is required despite 'required: []', or whether the two are mutually exclusive, optional, or composable. The description adds no meaning beyond restating the two input modes the schema already documents.

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

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

The description names a specific verb ('Generate'), resource ('3D asset'), engine ('Hunyuan3D'), and both input modalities ('text or image'). This clearly distinguishes it from the Hyper3D generation siblings, though it stops short of explicitly naming those alternatives.

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

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

No guidance is given on when to choose this tool over generate_hyper3d_model_via_text or generate_hyper3d_model_via_images, nor any mention of the surrounding workflow (poll_hunyuan_job_status, import_generated_asset_hunyuan). With both parameters optional in the schema, there is also no guidance on which input an agent should supply.

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 only restates the generation action and provides no information about whether the operation is asynchronous, whether it returns a job ID, whether polling is required, or what side effects or prerequisites exist. This leaves important behavior opaque.

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

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

The description is a single short sentence with no filler, front-loading the action and input type. Every word earns its place; the brevity is a structural strength even though the content is thin.

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 generation tool with no annotations, no output schema, and three optional-looking parameters, the description is incomplete. It does not explain that at least one image source is likely needed, does not indicate that generated assets may require polling or import via sibling tools, and gives no sense of the expected flow or return value.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning beyond the generic word 'images', and it does not clarify the relationship between input_image_urls and input_image_paths, whether at least one is required, or how bbox_condition affects generation.

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 identifies the verb ('Generate'), the resource ('3D asset using Hyper3D'), and the input medium ('from images'). It is understandable and differentiates from the sibling text-based generation tool by explicitly stating images as the source, though it is still very close to the tool name with little added specificity.

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

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

The phrase 'from images' implies this tool should be used when image-based input is available, which is a minimal usage signal. However, it does not explicitly contrast with generate_hyper3d_model_via_text, does not state prerequisites, and gives no guidance on when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says the tool generates an asset; it does not disclose whether generation is asynchronous, whether it returns a job ID, whether polling is required, or whether credits are consumed. Given sibling tools like 'poll_rodin_job_status' and 'import_generated_asset', these behavioral details are materially relevant.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word adds relevant information about the tool's 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?

The description is minimal and does not explain important context such as the asynchronous generation lifecycle, the expected output, or downstream steps like polling status and importing the generated asset. The presence of related poll/import/status siblings suggests this tool is part of a multi-step workflow, but the description leaves that implicit.

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

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

Schema description coverage is 100%, and the schema already explains 'text_prompt' and 'bbox_condition' clearly. The description adds no parameter-level meaning, but the schema is sufficient, so the baseline of 3 is appropriate.

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

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

The description states a specific action, 'Generate 3D asset', and names both the technology ('using Hyper3D') and the input mode ('from text description'). This clearly distinguishes it from the sibling tool 'generate_hyper3d_model_via_images' and from the Hunyuan-based generation 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 phrase 'from text description' provides a clear usage condition: this tool is appropriate when the user supplies a text prompt. It does not explicitly name alternatives or when-not-to-use conditions, but the input-mode context is clear enough for an agent to select this tool over image-based generation.

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 describing behavior. It clearly indicates the operation is a read-only check, but it does not disclose the return format, error behavior, or preconditions such as Blender running with the addon installed.

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

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

The description is a single, concise sentence with no filler. The verb and object are front-loaded, and every word contributes 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?

For a zero-parameter status probe, the description captures the core contract: it checks whether Hunyuan3D integration is enabled in Blender. Mentioning the return type would improve completeness, but the behavior is simple enough that the current description is nearly sufficient.

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

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

This tool has zero parameters and the schema coverage is 100%, so there are no parameter semantics to document. The description correctly avoids inventing unnecessary parameter details.

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') and a specific resource ('Hunyuan3D integration enabled in Blender'), making the tool's purpose immediately clear. It also distinguishes itself from sibling status tools by naming the exact integration being checked.

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?

There is no explicit statement of when to use this tool versus alternatives. However, the status-check semantics imply it should be used to verify Hunyuan3D availability before generation or import, and the sibling naming convention makes the intended scope 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 must carry behavioral disclosure. Saying it 'Check[s] if...enabled' conveys a read-only, non-mutating status check, but it does not explicitly mention side effects, return shape, or network dependency. This is minimally adequate for a zero-parameter 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?

A single, well-formed sentence with no filler. The core action and target are front-loaded and every word adds 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 tool's trivial complexity (no params, no output schema), the description is mostly complete: an agent can select and call it. It stops short of stating what the response looks like or when it should be used relative to the generation/poll siblings, so it is not a full 5.

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

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

There are zero parameters, so the baseline is 4. The description correctly implies no inputs are needed and does not need to explain 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 uses a specific verb ('Check') and a specific resource ('Hyper3D Rodin integration... enabled in Blender'), which cleanly separates it from sibling status tools like get_polyhaven_status and get_hunyuan3d_status. The meaning is unambiguous and 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?

No guidance is given on when to call this versus alternatives such as poll_rodin_job_status or get_hunyuan3d_status. The intended context (e.g., verify integration before generating a Hyper3D model) is only implied by the name and description, not stated.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. 'Get' implies a read-only lookup operation, which is helpful but not explicit about side-effect-free behavior. It does not disclose behavior for missing objects, error handling, or the exact return structure.

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

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

The description is a single short sentence that directly states the tool's purpose. It is front-loaded and contains no filler, redundant phrasing, or unnecessary detail.

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?

Although the tool has only one parameter and is relatively simple, there is no output schema and no annotation coverage. The description does not explain what 'detailed information' includes, what happens when the object name is invalid or missing, or what return format the agent should expect. This leaves important gaps for reliable 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 100% because object_name already has 'Name of the object' in the schema. The description adds a bit of context by specifying the object is 'in the scene,' but does not provide additional parameter-level meaning such as naming conventions, case sensitivity, or valid object name sources.

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 and resource: 'Get detailed information about a specific object in the scene.' It indirectly distinguishes itself from sibling get_scene_info by focusing on a specific object rather than the whole scene. However, 'detailed information' is vague and does not specify what details are included.

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 usage context is implied: use this tool when you need information about a named object in the scene. It does not explicitly state when to use it instead of alternatives like get_scene_info, nor does it mention any exclusions or prerequisites.

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 of behavioral disclosure. The verb 'get' implies a read-only operation and 'on PolyHaven' suggests external retrieval, but the description does not state side effects, network behavior, authentication needs, or what happens with an invalid asset_type.

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

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

The description is a single focused sentence with no filler. It front-loads the action and resource, and every word contributes to understanding the tool's 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 simple tool with one optional parameter and no output schema, the description plus schema parameter docs are mostly sufficient. It could be more complete by noting whether asset_type defaults to 'all' or by describing the returned categories, but the core usage is clear.

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 already provides 100% coverage for the only parameter, asset_type, with clear allowed values. The description adds minimal extra meaning by mentioning 'specific asset type,' but does not go beyond the schema's 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 a specific verb ('Get') and resource ('categories for a specific asset type on PolyHaven'), making the tool's function evident. It is distinct enough from sibling tools like search_polyhaven_assets or download_polyhaven_asset, though it does not explicitly call out that differentiation.

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

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

No guidance is given about when to use this tool versus alternatives such as search_polyhaven_assets or get_polyhaven_status. There are no exclusions, prerequisites, or context to help an agent decide between this and related PolyHaven 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, the description carries the full behavioral burden. 'Check if' indicates a read-only status query and suggests a boolean result, but it does not disclose what happens when Blender is not running, whether the check is local or remote, or the exact return shape. It is not misleading, just thin.

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

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

A single, front-loaded sentence with no filler. It names the operation, resource, and environment in nine words.

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

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

For a zero-parameter status check, the description is nearly sufficient. The main gap is the absence of an output schema or a stated boolean return convention, but 'Check if enabled' strongly implies a yes/no answer. It does not explain error conditions, though the tool's simplicity minimizes the risk.

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 tool has zero parameters and the schema already covers this completely at 100%, so the baseline of 4 applies; there is nothing for the description to add about 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?

States a specific check action, the PolyHaven integration resource, and the Blender context. It clearly differs from sibling status tools for other integrations (Sketchfab, Hyper3D, Hunyuan3D) by naming the distinct 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 description implies this is the status check for PolyHaven before using related PolyHaven tools, but it does not explicitly state when to use it or when to prefer sibling status tools. No exclusions or alternative conditions are given, leaving usage context to inference.

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

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

With no annotations, the description must carry the behavioral disclosure burden. 'Get' implies a read-only operation, but the description does not confirm side-effect status, response shape, or any environment requirements such as an open scene that might affect invocation.

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

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

A single, front-loaded sentence with no filler. For a parameterless getter, this length is appropriate and every word 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?

There is no output schema, so the description should hint at what 'detailed information' will contain, such as scene settings, object list, or render parameters. It does not, leaving the agent to guess what the tool returns and whether it is the right level of 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 tool accepts zero parameters, so there is no parameter burden on the description. Per the calibration baseline, a 0-parameter tool gets a 4 even without further parameter explanation.

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 a read operation ('Get') targeting a specific resource ('detailed information about the current Blender scene'), and its scene-level scope distinguishes it from get_object_info. However, 'detailed information' is vague and does not enumerate what is included.

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

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

No guidance is given about when to use this tool instead of sibling tools. It does not mention get_object_info for object-level queries or explain any conditions, prerequisites, or 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?

With no annotations provided, the description carries full behavioral disclosure burden. It does imply a read-only status check, but it does not describe whether it returns a boolean, status string, or any other shape, nor does it explain what 'enabled' means in operational terms. This is a minimal behavioral disclosure beyond the core purpose.

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

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

A single clear sentence with no filler or redundant wording. The essential subject, action, and scope are immediately 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 zero-parameter status check, the description adequately identifies the operation, but with no output schema it should clarify the expected return value (e.g., true/false or an enabled state). This gap leaves an agent slightly uncertain about how to use the result in downstream logic.

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 tool has zero parameters, so the description is not required to explain parameter meaning. The baseline of 4 applies because there is no parameter information that the description could add.

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') and names the exact resource and condition ('Sketchfab integration is enabled in Blender'). It clearly differentiates from sibling tools like get_polyhaven_status and get_hunyuan3d_status by naming Sketchfab explicitly.

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 an agent needs to verify whether Sketchfab integration is enabled before using Sketchfab-related tools. However, it does not explicitly state when not to use it or name alternatives, leaving some inference required.

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 states only the action and does not mention whether the screenshot is returned directly, saved to disk, or how max_size affects the output. This is a significant gap since there is also no output 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 a single direct sentence with no filler. The action and resource are front-loaded, and every word 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 simple read-only screenshot tool, the description covers the core action and the schema covers the only parameter. However, the absence of an output schema or annotations leaves the return format and side-effect profile under-specified. A brief note about what the agent receives would make it 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 sole parameter, max_size, is fully documented in the input schema with type and default. Since schema description coverage is 100%, the description does not need to repeat parameter details; however, it also adds no extra nuance about how max_size influences the screenshot.

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, 'Capture', and a clear resource, 'screenshot of the current Blender 3D viewport'. It clearly distinguishes this tool from all listed siblings, none of which perform screenshot capture.

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

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

The context is clear: this tool is for capturing the current Blender viewport, and there is no competing screenshot tool among the siblings. It does not state explicit when-not conditions, but the practical usage is obvious from the description.

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 of disclosing behavior. It only states what the tool does at a high level and does not mention side effects, requirements, mode behavior, or what happens if both task_uuid and request_id are provided or neither is. This is a meaningful gap for an import 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 a single, short sentence that is immediately understandable and contains no filler. It is front-loaded with the action and resource, making it easy to scan.

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 a Hunyuan import sibling and two mode-specific parameters with no annotations or output schema, the description is too thin to fully orient an agent. It lacks context about when importing is appropriate, how the mode parameters relate to the workflow, and what a successful import implies for the 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 100%, so the schema already documents all three parameters with meaningful descriptions. The tool description adds no parameter-level meaning beyond the schema, which matches the baseline expectation. The mode-specific hints in the schema are the main semantic content.

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 ('Import') and a specific resource ('asset generated by Hyper3D Rodin'), which distinguishes it from the sibling 'import_generated_asset_hunyuan' at least by source. It does not explain what the import does in the scene beyond the name, but the core purpose is identifiable.

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

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

No guidance is given about when to use this tool versus alternatives like generating a model, polling status, or importing a Hunyuan asset. The description implies it should be used after a Hyper3D generation completes, but that is not explicit, and mode-related selection criteria are left entirely to the parameter descriptions.

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 restates the import action; it does not disclose that this mutates the scene, downloads and extracts the ZIP, requires a completed generation, or what it returns or does 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?

A single sentence with no fluff and the source qualifier front-loaded. It is concise and readable, though somewhat too terse to carry the missing behavioral and usage context.

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, no-nested, no-output-schema import tool whose schema is fully self-descriptive, this is minimally usable: an agent can infer to pass a name and a ZIP URL from the Hunyuan generate step. However, with no annotations and no mention of return behavior or prerequisites, it is not rich enough to fully handle failure cases or pipeline sequencing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter meaning beyond the schema, which already documents name as 'Object name in scene' and zip_file_url as 'ZIP file URL from generate step'.

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

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

States a specific verb ('Import') and a clearly bounded resource ('asset generated by Hunyuan3D'). This immediately distinguishes it from the generic sibling import_generated_asset and from the download/generation tools in the same family.

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

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

The phrase 'generated by Hunyuan3D' implies this is for assets produced by the Hunyuan pipeline, as opposed to Polyhaven, Sketchfab, or Hyper3D assets. However, it never explicitly says when to call this versus import_generated_asset, nor does it state any prerequisites such as completing a prior generate_hunyuan3d_model step.

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 of behavioral disclosure. It communicates that this is a status check, but it does not say whether the call blocks until completion, what a non-completed result looks like, whether repeated polling is safe, or what response the agent should expect.

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

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

The description is a single, direct sentence with no filler or redundant wording. It is appropriately short for a simple status-check tool, though the lack of usage context prevents a perfect score.

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

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

For a polling tool with no output schema and no annotations, the description is incomplete: it does not explain the return shape, job lifecycle, or how this relates to the generate step. The schema covers job_id well, but the agent still lacks enough context to invoke and interpret the tool confidently.

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

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

Schema coverage is 100% and the single parameter job_id is already described as 'Job ID from generate step'. The tool description adds no additional parameter meaning, so it stays at the baseline for high schema 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 states a specific action and resource: checking whether a Hunyuan3D generation task is completed. It is clear enough on its own, but it does not distinguish itself from the sibling get_hunyuan3d_status, which may cover the same status-checking behavior.

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

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

No guidance is given about when to use this tool versus alternatives such as get_hunyuan3d_status or poll_rodin_job_status. The schema hints that the job_id comes from a generate step, but the description does not explain the intended polling workflow or 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 present, so the description carries the full burden. 'Check if ... is completed' implies a read-only status query but says nothing about return values, polling semantics (blocking vs immediate), error cases, or mode-specific 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?

A single sentence that is front-loaded and contains no filler. It is appropriately compact for a simple status check, though it offers no additional structured guidance.

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

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

With no output schema or annotations, agents need the description to clarify what the response looks like and how to identify a job. The description only says a task is completed/not completed; it doesn't state whether one of request_id or subscription_key is mandatory, how they correspond to FAL_AI vs MAIN_SITE modes, or what statuses exist. This is incomplete for reliable 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 coverage is 100%; each parameter has a brief mode hint. The tool description adds no meaning beyond naming the task, so it doesn't help resolve the ambiguity of having two optional parameters with no required ones. Baseline 3 applies because the schema already documents them.

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 (checking completion) on a specific resource (Hyper3D Rodin generation task), so an agent can infer the basic function. However, it does not differentiate from sibling get_hyper3d_status or poll_hunyuan_job_status, which likely serve similar status-checking roles.

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 no information about when to poll this status versus using get_hyper3d_status, or when to use request_id versus subscription_key. No exclusions or alternatives are named, leaving the agent to choose purely on 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool searches and can filter; it does not mention result format, network access, pagination, or any side effects. This is insufficient for an unannotated 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 a single front-loaded sentence with no redundant information. It puts the primary action and object first, making it easy to scan, and there is no irrelevant 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?

This is a search tool with no output schema and no annotations, so the description should explain what the agent can expect back. It does not mention return values, valid categories, or the need to consult get_polyhaven_categories for category values, leaving the invocation context incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds only the generic notion of 'optional filtering' and does not enhance the parameter meanings already present in the schema, which accurately documents asset_type and categories at a basic level.

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: 'Search for assets on PolyHaven'. It conveys the tool's core function and is distinguishable from siblings like download_polyhaven_asset and get_polyhaven_status. However, it does not explicitly differentiate itself from search_sketchfab_models or name the filtering dimensions, leaving slight room for 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?

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites or exclusions. The phrase 'with optional filtering' is the only context, which is too vague to help an agent decide between this and related search or 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Search' implies a read-only operation, but the description does not mention return format, pagination behavior, external service dependency, or any limitations. This is a significant gap for a tool with no annotation safety signals.

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

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

The description is a single concise sentence with no filler or redundant information. It is front-loaded with the primary action and resource, making it immediately understandable.

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 schema covers all parameters, but there is no output schema and no description of what the search results look like or how they connect to downstream actions like downloading a model. For a search tool, this is adequate but not complete, especially given the absence of annotations and usage guidance.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters sufficiently. The description adds no additional parameter semantics beyond what the schema provides, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Search for models on Sketchfab.' It is clear and distinguishable from sibling tools like download_sketchfab_model and get_sketchfab_status, though it does not explicitly contrast itself with search_polyhaven_assets beyond the Sketchfab qualifier.

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?

There is no guidance on when to use this tool versus alternatives, no mention of prerequisites, and no suggestion of the typical workflow of searching before downloading. The context signals and sibling names imply the usage, but the description itself provides no explicit direction.

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?

Since no annotations are provided, the description carries the full burden of disclosing behavior. It states the core operation but gives no information about side effects (e.g., replacing existing materials), reversibility, permissions, or failure modes. For a mutation tool, this is a significant 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 description is a single concise sentence that places the action and target up front. There is no wasted wording, and it fully fits a tool with only two parameters.

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 core operation and the schema documents both parameters, but important context is missing: the need for a previously downloaded texture, whether the object must already exist, and what happens to existing materials. This leaves the definition adequate but with 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?

Schema description coverage is 100%, with both texture_id and object_name described in the schema. The tool description adds little beyond that, merely restating the texture/object concepts, so it does not improve on the baseline provided by 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 names a specific verb ('Apply'), a specific resource ('a downloaded PolyHaven texture'), and a target ('to an object'). This clearly distinguishes it from sibling tools like download_polyhaven_asset or search_polyhaven_assets, which handle other stages of the texture workflow.

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

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

The description offers no explicit when-to-use guidance, exclusions, or alternatives. The word 'downloaded' implies a prerequisite step, but it does not clearly instruct the agent to download the texture first or to ensure the target object exists, and no sibling tool is named as an alternative.

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