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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Download and import') but doesn't mention critical behaviors: whether this requires internet connectivity, what happens if the asset already exists, if it overwrites files, expected download time, file size implications, or Blender integration specifics. The return message is mentioned but not elaborated.

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 appropriately sized and well-structured: a clear purpose statement followed by a parameter breakdown. Every sentence earns its place by providing essential information. It could be slightly more front-loaded by integrating parameter constraints into the initial statement, but overall it's efficient.

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 and no output schema, the description does an adequate job explaining parameters but lacks behavioral context. It doesn't cover error conditions, performance characteristics, or integration details with Blender. The mention of return message is minimal. Given the complexity, it meets minimum viability 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?

With 0% schema description coverage, the description fully compensates by explaining all 4 parameters with clear semantics. It defines 'asset_id', 'asset_type' with examples (hdris, textures, models), 'resolution' with format examples, and 'file_format' with type-specific examples. This adds substantial value 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 specific action ('Download and import'), target resource ('Polyhaven asset'), and destination ('into Blender'). It distinguishes from siblings like 'search_polyhaven_assets' (which finds assets) and 'import_generated_asset' (which imports from other sources). The verb+resource+destination combination is precise and unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing to search for assets first using 'search_polyhaven_assets'), nor does it differentiate from similar tools like 'download_sketchfab_model' or 'import_generated_asset'. Usage context is implied but not explicitly 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 full burden of behavioral disclosure. It mentions access rights and downloadability as prerequisites, but doesn't describe what happens during import (e.g., file format, destination, potential side effects), error conditions, or response format beyond a success/failure message. This is inadequate for a mutation tool with zero 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 description is efficiently structured with a clear purpose statement followed by parameter and return information. It avoids unnecessary words, though the prerequisites could be integrated more smoothly. Every sentence serves a functional 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 mutation tool with no annotations, no output schema, and a single parameter, the description is incomplete. It lacks details on import behavior (e.g., where files go, supported formats), error handling, and doesn't fully compensate for the missing structured data, leaving the agent with significant uncertainty.

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 explicitly documents the single parameter ('uid: The unique identifier of the Sketchfab model'), which adds value since schema description coverage is 0%. However, it doesn't provide format examples, constraints, or where to find the UID, leaving some semantic gaps.

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 ('Download and import') and the resource ('a Sketchfab model by its UID'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'search_sketchfab_models' or 'import_generated_asset', which would be needed for a perfect score.

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 mentions prerequisites ('The model must be downloadable and you must have proper access rights'), but provides no guidance on when to use this tool versus alternatives like 'import_generated_asset' or 'search_sketchfab_models'. It lacks explicit when/when-not instructions or named 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 carries full burden. It mentions executing 'arbitrary Python code' and suggests a step-by-step approach, but fails to disclose critical behavioral traits such as security implications, execution environment details, error handling, or potential side effects (e.g., modifying Blender scenes). This is a significant gap for a tool with mutation capabilities.

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 appropriately sized with two sentences: one stating the purpose and one providing parameter info. It's front-loaded with the core functionality, though the second sentence could be more structured. There's no wasted text, making it efficient.

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 complexity of executing arbitrary code in Blender, no annotations, no output schema, and low schema coverage, the description is incomplete. It misses essential context like return values, error conditions, or execution limits, which are critical for safe and effective use by an AI agent.

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 minimal semantics beyond the input schema: it names the 'code' parameter and states it's 'The Python code to execute'. With 0% schema description coverage and 1 parameter, this provides basic context but lacks details like code format, constraints, or examples. The baseline is 3 due to the single parameter, but it doesn't fully compensate for the coverage 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 'execute' and the resource 'arbitrary Python code in Blender', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'import_generated_asset' or 'set_texture', which might also involve Blender operations but with different scopes.

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 implied usage guidance by suggesting to 'break it into smaller chunks', which hints at a step-by-step approach for complex code. However, it lacks explicit when-to-use rules, alternatives (e.g., vs. other Blender tools), or exclusions, leaving the agent to infer context from the tool name and sibling list.

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 describes the generation process, import into Blender, built-in materials, and normalized size, which are useful behavioral traits. However, it doesn't mention important aspects like whether this is a long-running operation, what permissions are needed, error handling, or what the success/failure messages contain. The description adds value but leaves significant gaps in behavioral understanding.

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 a clear opening statement followed by a dedicated parameters section. Each sentence adds value, though the middle section about materials and scaling could be more tightly integrated. It's appropriately sized for a tool with 3 parameters and complex behavior, with no redundant information.

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 complexity (3D generation from images, import to Blender, multiple modes), no annotations, and no output schema, the description provides good parameter coverage but lacks important context. It doesn't explain the return value beyond 'success or failure' message, doesn't mention performance characteristics, error conditions, or how this integrates with the broader 3D workflow alongside sibling tools. The description is adequate but has clear gaps for a tool of this 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?

With 0% schema description coverage, the description fully compensates by providing detailed parameter semantics. It explains the purpose of input_image_paths and input_image_urls, their relationship to Hyper3D Rodin modes, the requirement to wrap single images in lists, and the optional bbox_condition with its format and effect. This adds substantial meaning beyond what the bare schema provides.

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

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

The description clearly states the tool generates a 3D asset using Hyper3D from images and imports it into Blender, with specific details about built-in materials and normalized size. It distinguishes from sibling 'generate_hyper3d_model_via_text' by specifying image-based input, but doesn't fully differentiate from other 3D-related tools like 'import_generated_asset' or 'download_polyhaven_asset' in terms of when to choose this specific 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 provides clear context about when to use input_image_paths vs input_image_urls based on Hyper3D Rodin's mode (MAIN_SITE vs FAL_AI), and mentions re-scaling after generation can be useful. However, it doesn't explicitly state when to use this tool versus alternatives like 'generate_hyper3d_model_via_text' or other 3D asset acquisition tools, nor does it mention any 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 the full burden of behavioral disclosure. It adds useful context about the generated model having built-in materials and normalized size requiring rescaling, but does not cover important aspects like permissions needed, rate limits, whether the operation is idempotent, or what specific success/failure messages look like.

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 efficiently structured with a clear purpose statement upfront, followed by key behavioral details, and then parameter explanations. Every sentence adds value without redundancy, and the information is appropriately 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 tool with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description provides adequate basic information but lacks details about error conditions, what the return message contains beyond success/failure indication, and how the import process interacts with Blender's current state.

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?

With 0% schema description coverage, the description compensates well by explaining both parameters: 'text_prompt' is described as 'A short description of the desired model in English' and 'bbox_condition' is explained as controlling the length/width/height ratio with format details. However, it doesn't specify units or valid ranges for bbox_condition values.

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 with specific verbs ('Generate 3D asset using Hyper3D' and 'import the asset into Blender'), identifies the resource (3D asset), and distinguishes it from sibling tools like 'generate_hyper3d_model_via_images' by specifying it works via text description rather than images.

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 context for when to use this tool (to generate 3D assets from text descriptions and import them to Blender), but does not explicitly state when not to use it or name alternatives like 'generate_hyper3d_model_via_images' for image-based generation, though the distinction is implied by the tool name and 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?

No annotations are provided, so the description carries the full burden. It states the tool checks status and returns a message, but lacks behavioral details: it doesn't specify if this is a read-only operation (implied but not explicit), what the message format is, potential error conditions, or performance characteristics. The cryptic note about 'Don't emphasize the key type...' adds confusion rather than clarity.

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 brief but inefficiently structured. The first two sentences clearly state purpose and return value. However, the third sentence ('Don't emphasize the key type...') is cryptic and doesn't add value for tool selection or invocation, reducing conciseness. It's front-loaded but includes a confusing element.

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, no output schema, and 0 parameters, the description is incomplete. It mentions a return message but doesn't describe its format, structure, or possible values (e.g., boolean, detailed status). For a status-check tool, this leaves the agent uncertain about how to interpret results. The cryptic note further detracts from 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 tool has 0 parameters, and schema description coverage is 100% (empty schema). With no parameters, the baseline is 4. The description appropriately doesn't discuss parameters, as none exist, so it doesn't need to compensate for any gaps.

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: 'Check if Hyper3D Rodin integration is enabled in Blender' (specific verb + resource). It distinguishes from siblings by focusing on Hyper3D Rodin status, unlike tools for downloading assets, executing code, or getting scene info. However, it doesn't explicitly differentiate from similar status-check tools like get_polyhaven_status or get_sketchfab_status beyond the specific integration name.

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. It doesn't mention prerequisites (e.g., when this check is needed), exclusions, or comparisons to sibling tools like get_polyhaven_status. The only implied usage is checking Hyper3D Rodin availability, but no context for why or when that matters 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 full burden for behavioral disclosure. It states the tool retrieves 'detailed information' but doesn't specify what that includes (e.g., object type, location, properties), whether it's read-only, error handling for invalid object names, or performance characteristics. This leaves significant gaps 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 description is appropriately concise with two sentences: a clear purpose statement and a parameter list. The structure is front-loaded with the core functionality, though the parameter section could be integrated more smoothly (e.g., 'Get detailed information about a specific object in the Blender scene by providing its object_name.').

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

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

Given the tool's moderate complexity (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the purpose and parameter but lacks details on return values, error conditions, and behavioral traits. For a read operation in a 3D modeling context, more context on information scope would be beneficial.

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 explicitly lists the single parameter 'object_name' with a brief explanation ('The name of the object to get information about'), adding meaningful context beyond the schema's 0% description coverage. Since there's only one parameter, this adequately compensates for the schema gap, though it doesn't detail format constraints (e.g., case-sensitivity, naming conventions).

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 detailed information') and resource ('a specific object in the Blender scene'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_scene_info' or 'get_viewport_screenshot', which also retrieve Blender scene information but at different scopes.

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. It doesn't mention sibling tools like 'get_scene_info' (for broader scene overview) or 'get_viewport_screenshot' (for visual capture), leaving the agent to infer usage context from tool names alone.

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 burden but offers minimal behavioral insight. It states it 'gets a list' which implies a read operation, but doesn't disclose rate limits, authentication needs, error handling, or what the returned list structure looks like. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.

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 appropriately brief with two sentences: one stating the purpose and one explaining the parameter. It's front-loaded with the core functionality. There's no wasted text, though it could be slightly more structured (e.g., bullet points aren't used consistently).

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 1 parameter with 0% schema coverage and no output schema, the description does an adequate job explaining the parameter but lacks completeness. It doesn't describe the return value format (list structure, categories examples), error conditions, or how 'all' differs from specific types. For a simple lookup tool, it's minimally viable 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 description adds meaningful context beyond the input schema. The schema only shows asset_type as a string with default 'hdris', but the description enumerates the valid options (hdris, textures, models, all) and clarifies it's for 'a specific asset type'. With 0% schema description coverage and 1 parameter, this compensates well by providing the enum values that aren't in the schema.

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

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

The description clearly states the verb ('Get a list of categories') and resource ('for a specific asset type on Polyhaven'), making the purpose explicit. It distinguishes from some siblings like download_polyhaven_asset or search_polyhaven_assets by focusing on categories rather than assets themselves. However, it doesn't explicitly differentiate from all siblings (e.g., get_polyhaven_status might be related but different).

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. It doesn't mention prerequisites, when it's appropriate compared to other Polyhaven tools (like search_polyhaven_assets), or any context for selecting asset_type. Usage is implied only through the parameter description, with no explicit when/when-not statements.

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 the tool 'Returns a message indicating whether PolyHaven features are available,' which covers the basic output behavior. However, it lacks details on potential errors (e.g., if Blender isn't running), performance aspects, or any side effects. For a tool with zero annotation coverage, this is a significant gap in 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 description is concise and well-structured with two sentences: the first states the purpose, and the second explains the return value. There is no wasted text, and it's front-loaded with the core functionality. Every sentence earns its place by adding 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?

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does and what it returns, but without annotations or output schema, it should ideally provide more behavioral context (e.g., error handling or integration specifics). It meets the minimum viable threshold but could be more complete.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add any parameter information, which is appropriate. A baseline of 4 is applied for zero parameters, as the description doesn't need to compensate for schema gaps.

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: 'Check if PolyHaven integration is enabled in Blender.' This specifies the verb ('Check') and resource ('PolyHaven integration'), and it distinguishes from siblings like 'get_hyper3d_status' or 'get_sketchfab_status' by focusing on PolyHaven. However, it doesn't explicitly differentiate from 'get_polyhaven_categories', which is a minor gap.

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 needing to verify PolyHaven availability, but it doesn't provide explicit guidance on when to use this tool versus alternatives. For example, it doesn't mention if this should be called before using 'download_polyhaven_asset' or 'search_polyhaven_assets', nor does it specify any prerequisites or exclusions. This leaves usage context somewhat vague.

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 burden but only states what the tool does, not how it behaves. It lacks details on permissions, rate limits, output format, or error handling, which are critical for a tool with 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, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a zero-parameter tool, though it could be slightly more structured with 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?

Given the lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what 'detailed information' includes, the return format, or behavioral aspects, leaving significant gaps for the agent to operate effectively.

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 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a high baseline score for this dimension.

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 ('Get detailed information') and resource ('about the current Blender scene'), providing a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'get_object_info' or 'get_viewport_screenshot', which prevents a perfect score.

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 guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage based on the tool name alone.

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 the tool 'Returns a message indicating whether Sketchfab features are available,' which clarifies it's a read-only status check. However, it lacks details on potential errors, response format, or any side effects (though implied safe). This is adequate but minimal for a no-param 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 highly concise and well-structured, consisting of two sentences that directly state the action and the return value. Every word earns its place, with no redundancy or fluff, making it easy for an agent to parse quickly.

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 (0 parameters, no annotations, no output schema), the description is minimally complete. It explains what the tool does and what it returns, but lacks details on the return message format or error handling. For a status-check tool, this is adequate but leaves gaps in full behavioral understanding.

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 0 parameters, with schema description coverage at 100%. The description doesn't need to explain parameters, and it doesn't add any parameter-related information beyond the schema. A baseline of 4 is appropriate for zero-parameter tools, as there's no parameter burden to compensate for.

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: 'Check if Sketchfab integration is enabled in Blender.' It specifies the verb ('Check') and resource ('Sketchfab integration in Blender'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_hyper3d_status' or 'get_polyhaven_status' beyond the resource name, which prevents a perfect score.

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. It doesn't mention prerequisites, context (e.g., before downloading models), or exclusions. With sibling tools like 'download_sketchfab_model' and 'search_sketchfab_models', the lack of usage context is a significant gap, leaving the agent to infer when this check is necessary.

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 burden but lacks critical behavioral details. It mentions the tool returns an Image but doesn't specify format (e.g., PNG, JPEG), dimensions, or whether the capture is immediate or queued. It also omits potential side effects like pausing rendering or requiring specific viewport settings.

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 core purpose in the first sentence, followed by a clear parameter section. Every sentence earns its place by providing essential information without redundancy or fluff, making it highly efficient.

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, 0% schema description coverage, and no output schema, the description is moderately complete for a simple tool but has gaps. It covers purpose and parameter semantics adequately but lacks details on return format, error conditions, and behavioral constraints, which are important for a capture operation.

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 meaningful context for the single parameter 'max_size', explaining it's the 'Maximum size in pixels for the largest dimension' with a default of 800. Since schema description coverage is 0% (schema only lists type and title), this compensates well, though it could clarify if values are clamped or have min/max bounds.

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 ('Capture a screenshot') and target resource ('current Blender 3D viewport'), distinguishing it from all sibling tools which involve downloading assets, executing code, getting status/info, searching, importing, or setting textures. No sibling tool performs viewport 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 description implies usage when a screenshot of the Blender viewport is needed, but provides no explicit guidance on when to use this tool versus alternatives (e.g., other screenshot methods or tools for different visual outputs). It doesn't mention prerequisites like requiring Blender to be running or having a viewport open.

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. It mentions that the tool imports an asset and returns success status, but lacks details on permissions, error handling, rate limits, or what 'import' entails (e.g., where the asset is stored, if it overwrites existing assets). For a mutation tool with zero annotation coverage, this is a significant gap in behavioral disclosure.

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 appropriately sized and front-loaded with the main purpose. The parameter explanations are necessary given the lack of schema descriptions. However, the last sentence about the return value could be integrated more smoothly, and there's minor redundancy in specifying 'Hyper3D Rodin' multiple times.

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 complexity (mutation tool with 3 parameters, no annotations, no output schema), the description is moderately complete. It covers the purpose, usage context, and parameter semantics adequately, but lacks details on behavioral aspects like error cases, side effects, or output format. For a tool that performs an import operation, more context on what 'successfully' means would be beneficial.

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 adds crucial semantic information: 'name' is the object name in the scene, 'task_uuid' is for MAIN_SITE mode from a generate step, and 'request_id' is for FAL_AI mode from a generate step. It also specifies the exclusive choice between task_uuid and request_id. This goes well beyond the bare schema, though it doesn't cover all possible nuances (e.g., format of IDs).

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 ('Import') and the resource ('asset generated by Hyper3D Rodin'), making the purpose understandable. It distinguishes from siblings by specifying it's for assets generated by Hyper3D Rodin, not downloaded from external sources like Polyhaven or Sketchfab. However, it doesn't explicitly contrast with all siblings, so it's not a perfect 5.

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 context on when to use this tool: after a generation task is completed in Hyper3D Rodin, and it specifies which parameter to use based on the mode (MAIN_SITE vs FAL_AI). It doesn't explicitly state when NOT to use it or name alternatives, but the context is sufficient for informed usage.

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 burden and does well. It discloses this is a polling API, explains completion criteria for both modes, describes failure states, and provides behavioral context about when to proceed. It doesn't mention rate limits, authentication needs, or error handling details, but covers the essential operational 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 appropriately sized and front-loaded with the core purpose. It efficiently organizes information by mode, though could be slightly more concise. Every sentence adds value: explaining parameters, return values, completion criteria, failure states, and polling behavior.

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 no annotations, no output schema, and 0% schema coverage, the description provides substantial context. It explains what the tool does, when to use it, parameter meanings, return value interpretation, and polling behavior. The main gap is lack of explicit error handling guidance, but overall it's quite complete given the 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?

With 0% schema description coverage for 2 parameters, the description fully compensates. It explains that 'subscription_key' is used for MAIN_SITE mode and 'request_id' for FAL_AI mode, specifying these come 'from the generate model step.' This adds crucial context beyond the bare parameter names in the schema.

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

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

The description clearly states the tool's purpose: 'Check if the Hyper3D Rodin generation task is completed.' It specifies the exact action (check/verify completion) and resource (Hyper3D Rodin generation task), distinguishing it from sibling tools like 'get_hyper3d_status' which likely provides different status information.

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

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

The description provides explicit guidance on when to use this tool: 'This is a polling API, so only proceed if the status are finally determined.' It distinguishes between two modes (MAIN_SITE and FAL_AI) with different parameter requirements, and implicitly contrasts with other status-checking tools by focusing specifically on Rodin job completion.

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 burden but offers minimal behavioral context. It mentions optional filtering and returns 'basic information,' but doesn't disclose pagination, rate limits, authentication needs, error conditions, or what constitutes 'basic information' in the response. This is inadequate for a search tool with zero 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 description is appropriately concise with three sentences: purpose statement, parameter explanations, and return value note. It's front-loaded with the core function, though the parameter list could be integrated more smoothly. No wasted words, but structure is basic.

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 complexity (search with filtering), lack of annotations, no output schema, and incomplete parameter documentation, the description is insufficient. It doesn't explain the response format, error handling, or usage constraints, leaving significant gaps for an AI agent to operate effectively.

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 some semantic context beyond the schema: it explains that 'asset_type' accepts specific values (hdris, textures, models, all) and that 'categories' is comma-separated. However, with 0% schema description coverage and 2 parameters, this only partially compensates—it doesn't clarify category format or provide examples. Baseline is 3 since it adds meaningful but incomplete 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 clearly states the tool's purpose as 'Search for assets on Polyhaven with optional filtering,' which is a specific verb+resource combination. It distinguishes from obvious siblings like 'download_polyhaven_asset' by focusing on search rather than retrieval, though it doesn't explicitly differentiate from 'search_sketchfab_models' beyond the platform name.

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. It doesn't mention when to prefer this over 'search_sketchfab_models' for different asset types or platforms, nor does it specify prerequisites or contextual triggers for initiating a search.

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 burden for behavioral disclosure. It mentions that it 'Returns a formatted list of matching models,' which gives some output context, but lacks details on authentication needs, rate limits, error handling, pagination, or what 'formatted' entails. For a search tool with zero annotation coverage, this leaves significant 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 well-structured and concise. It starts with a clear purpose statement, then lists parameters with brief explanations, and ends with return information. Every sentence earns its place with no wasted words, and it's appropriately sized for a 4-parameter search 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?

Given the tool's moderate complexity (search with filtering), no annotations, and no output schema, the description is partially complete. It covers parameters well but lacks behavioral context like authentication, rate limits, or detailed output format. For a tool with no structured safety or output information, it should provide more guidance on these aspects.

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 provides clear semantic explanations for all 4 parameters: 'query' as 'Text to search for,' 'categories' as 'Optional comma-separated list of categories,' 'count' as 'Maximum number of results to return (default 20),' and 'downloadable' as 'Whether to include only downloadable models (default True).' This adds substantial value 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 tool's purpose: 'Search for models on Sketchfab with optional filtering.' This specifies the verb ('search'), resource ('models on Sketchfab'), and scope ('with optional filtering'). However, it doesn't explicitly differentiate from sibling tools like 'search_polyhaven_assets' beyond the platform name.

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. It doesn't mention sibling tools like 'search_polyhaven_assets' for different platforms or 'download_sketchfab_model' for subsequent actions. There's no context about prerequisites, typical use cases, 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 burden for behavioral disclosure. It mentions that the texture must be 'previously downloaded', which adds useful context about prerequisites. However, it fails to disclose critical behavioral traits such as whether this operation is destructive (e.g., overwrites existing textures), requires specific permissions, has rate limits, or what happens on failure beyond a generic 'message'. For a mutation tool with zero annotation coverage, 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 appropriately sized and front-loaded: the first sentence states the core purpose, followed by a clear parameter list and return information. Every sentence earns its place by adding essential details without redundancy. The structure is logical and easy to parse, making it highly efficient for an AI agent.

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 complexity of applying textures (a mutation operation), no annotations, no output schema, and 2 parameters, the description is minimally adequate. It covers the purpose, parameters, and a basic return indication, but lacks details on behavioral aspects like error conditions, side effects, or output format. For a tool that modifies state, this leaves gaps that could hinder correct agent invocation, though it meets a baseline level of 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 explicitly lists both parameters with brief semantics: 'object_name' as 'Name of the object to apply the texture to' and 'texture_id' as 'ID of the Polyhaven texture to apply (must be downloaded first)'. This adds meaningful context beyond the schema, which has 0% description coverage and only provides titles. The constraint on 'texture_id' being downloaded first is particularly valuable. With 2 parameters fully covered in the description, it compensates well for the low 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 clearly states the action ('Apply') and resources ('previously downloaded Polyhaven texture' to 'an object'), making the purpose understandable. It distinguishes from siblings like 'download_polyhaven_asset' by focusing on application rather than acquisition. However, it doesn't explicitly differentiate from other texture-related tools that might exist, keeping it at 4 instead of 5.

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 by stating the texture 'must be downloaded first', which references the sibling tool 'download_polyhaven_asset'. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'import_generated_asset' or other texture application methods, nor does it mention when not to use it. This leaves usage context somewhat inferred rather than clearly defined.

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