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 effectively describes the asynchronous nature of the operation, the need for polling with another tool, and the expected workflow. It doesn't mention rate limits, authentication requirements, or error handling specifics, but provides substantial behavioral context beyond basic functionality.

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 with clear sections. The workflow steps are numbered for clarity. While comprehensive, some information could be more concise, such as the detailed workflow that spans multiple sentences. Overall, most content earns its place in helping the agent understand the tool's usage.

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 (asynchronous operation requiring polling), no annotations, and the presence of an output schema, the description provides excellent contextual completeness. It explains the asynchronous nature, the required follow-up actions, the return value usage, and references the output schema's content. This adequately compensates for the lack of annotations.

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

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

With 0% schema description coverage, the description must compensate for the lack of parameter documentation. It provides clear explanations for all 3 parameters mentioned (image, face_limit, auto_size), though the input schema only shows 2 parameters (missing auto_size). The description adds meaningful context about what each parameter controls, though there's a parameter mismatch between description and 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 ('Create a 3D model from an image') and identifies the resource ('using the Tripo API'). It distinguishes from sibling tools like 'create_3d_model_from_text' by specifying the image input source, and from 'import_tripo_glb_model' by indicating generation rather than import.

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 ('initiates a 3D model generation task') and when not to use it ('does NOT wait for completion'). It clearly names the alternative tool ('get_task_status') that must be used in conjunction and provides a detailed 6-step workflow for proper 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 an excellent job explaining the asynchronous behavior, workflow requirements, and expected response structure. It discloses that this is an initiation tool requiring follow-up calls, describes the polling pattern, and explains how to access the final result via pbr_model_url.

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 perfectly structured with clear sections: purpose statement, important behavioral note, numbered workflow steps, and parameter/return explanations. Every sentence earns its place by providing essential information without redundancy.

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

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

Given the tool's complexity (asynchronous operation requiring workflow coordination) and the presence of an output schema, the description provides complete context. It explains the asynchronous nature, the required follow-up workflow with sibling tools, parameter meanings, and what to expect in responses - covering everything an agent needs to use this tool correctly.

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

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

With 0% schema description coverage, the description compensates by explaining all 3 parameters mentioned in the Args section. It clarifies what 'describe_the_look_of_object' should contain, what 'face_limit' controls, and what 'auto_size' does. However, the input schema only shows 2 parameters, creating a minor discrepancy with the description mentioning 3.

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

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

The description clearly states the specific action ('Create a 3D model from a text description') and identifies the resource ('using the Tripo API'). It distinguishes this tool from siblings like 'create_3d_model_from_image' by specifying it works from text input 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 explicit workflow instructions with numbered steps, including when to use this tool (to initiate generation) and when to use the sibling 'get_task_status' tool (to check completion). It clearly states this tool doesn't wait for completion and must be followed by status checks.

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 this creates a new object but doesn't cover important aspects like whether this requires specific permissions, if it's destructive to existing scene elements, what happens on failure, or typical response behavior. The description is minimal beyond the basic action.

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 perfectly structured and concise. It starts with the core purpose in one sentence, then provides a clean bulleted list of parameters with clear explanations. Every sentence earns its place with no wasted 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?

Given that there's an output schema (which handles return values), no annotations, and 5 parameters with good description coverage, the description is reasonably complete for the basic operation. However, for a creation tool in a 3D modeling context, it could benefit from mentioning typical use cases, limitations, or integration with other tools.

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

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

The description provides excellent parameter semantics that compensate for the 0% schema description coverage. It clearly explains what each parameter represents (object type with specific enum values, optional name, location coordinates, rotation in radians, scale factors), adding substantial meaning beyond the bare schema.

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

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

The description clearly states the verb ('Create') and resource ('new object in the Blender scene'), making the purpose immediately understandable. However, it doesn't distinguish this tool from siblings like 'create_3d_model_from_image' or 'create_3d_model_from_text', which also create objects but through different methods.

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 siblings like 'create_3d_model_from_image' (for creating from images) or 'modify_object' (for editing existing objects), leaving the agent to guess based on 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 only states the basic action. It doesn't disclose critical behavioral traits such as whether deletion is permanent, requires specific permissions, affects scene hierarchy, or has side effects like removing associated materials. This is inadequate for a destructive 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 extremely concise with two sentences: one stating the purpose and another listing parameters. It's front-loaded with the core action and wastes no words, making it easy 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 destructive nature, lack of annotations, and presence of an output schema (which might cover return values), the description is minimally adequate. It covers the basic action and parameter but misses important context like safety warnings or usage scenarios, leaving gaps for a mutation 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 description adds meaningful context for the single parameter by specifying it's the 'Name of the object to delete', which clarifies its role beyond the schema's generic 'Name' title. With 0% schema description coverage and only one parameter, this compensates well, though it doesn't detail format or constraints.

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

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

The description clearly states the action ('Delete') and resource ('object from the Blender scene'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'modify_object' or 'create_object' beyond the verb, 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?

No guidance is provided on when to use this tool versus alternatives like 'modify_object' or 'create_object', nor any prerequisites or exclusions. The description only states what it does, not when it's appropriate.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the operation (download and import) and return value (success/failure message), but doesn't cover important behavioral aspects like whether this requires internet connectivity, what happens if the asset already exists, potential file size implications, or any rate limits. For a tool with no annotation coverage, this leaves significant 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 perfectly structured and concise. It starts with a clear purpose statement, then provides a bulleted list of parameters with helpful explanations, and ends with return value information. Every sentence earns its place with no wasted 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?

Given the tool has an output schema (which handles return values), 4 parameters with excellent description coverage, and no annotations, the description is quite complete. It explains what the tool does, all parameters meaningfully, and mentions the return type. The main gap is insufficient behavioral context for a download/import operation with no annotation coverage.

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

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

The description provides excellent parameter semantics beyond the 0% schema description coverage. It clearly explains each parameter's purpose: asset_id identifies the specific asset, asset_type categorizes it, resolution specifies download quality, and file_format offers format options with examples for each asset type. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the specific action ('Download and import'), the target resource ('Polyhaven asset'), and the destination environment ('into Blender'). It distinguishes this tool from siblings like search_polyhaven_assets or import_tripo_glb_model by specifying the download+import operation for Polyhaven assets specifically.

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 obtain Polyhaven assets for Blender, but doesn't explicitly state when to use this versus alternatives like import_tripo_glb_model or when not to use it (e.g., for non-Polyhaven assets). It provides some context but lacks explicit guidance on alternatives 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. It states the action but lacks critical details: it doesn't specify security implications, execution environment constraints, error handling, or output behavior. For a tool executing arbitrary code, 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 appropriately sized with two sentences: one stating the purpose and another listing the parameter. It's front-loaded and avoids unnecessary details, though the parameter listing could be integrated more seamlessly for better flow.

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, the lack of annotations, and the presence of an output schema (which handles return values), the description is minimally adequate. It covers the basic action but misses critical context like safety warnings or execution scope, making it incomplete for high-risk operations.

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 by naming the 'code' parameter and stating it's 'Python code to execute', but with 0% schema description coverage and only one parameter, this provides basic context. It doesn't elaborate on code format, Blender API usage, or examples, keeping it at the baseline for a single-parameter tool.

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 specific and understandable. However, it doesn't explicitly differentiate from siblings like 'modify_object' or 'create_object' which might also involve code execution in different contexts, preventing 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, limitations, or compare it to sibling tools like 'modify_object' that might handle specific object modifications, leaving the agent without contextual usage cues.

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

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

With no annotations provided, the description must disclose behavioral traits. It only says 'Get detailed information' without stating that it is read-only, what happens if the object does not exist, or any side effects. This is a significant gap for a tool that relies on the description for 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: one clear sentence plus a short parameter explanation. It is front-loaded with the primary purpose, and every sentence adds value without unnecessary 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?

Given the tool is a simple getter with an output schema available, the description adequately covers the only parameter and the core action. It does not mention error conditions or that the object must exist, but the output schema likely handles return values. Minor gap for a low-complexity 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 only provides a title 'Object Name' and type string, with no description. The tool description adds meaning by clarifying that object_name is 'the name of the object to get information about.' This compensates for the 0% schema description coverage.

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

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

The description clearly states the tool's purpose: 'Get detailed information about a specific object in the Blender scene.' This is a specific verb (get) + resource (object) + scope (specific object), which distinguishes it from the sibling tool get_scene_info that targets the whole scene.

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—you use it when you need info about a specific object—but it does not explicitly mention alternatives or when not to use it. No reference to get_scene_info or other sibling tools for broader context, so only implied guidance.

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

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

The verb 'Get' implies a read-only operation, and the parameter explanation clarifies the asset_type scope. However, with no annotations provided, the description carries the full transparency burden and does not disclose behaviors such as error handling for invalid asset_type values or the exact structure of the returned category list. For a simple read tool this is adequate but not rich.

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

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

The description is extremely concise: one sentence for the tool purpose and one line for the parameter. It is front-loaded and contains no unnecessary words, every sentence earning 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?

Given the tool's simplicity (only one optional parameter) and the presence of an output schema, the description fully covers the essential information. It specifies the parameter's allowed values and the resource being accessed. No critical behavioral or parameter details are 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?

The input schema provides no description for asset_type (0% coverage), but the description's Parameters section explicitly lists allowed values (hdris, textures, models, all) and explains the parameter's meaning. This fully compensates for the schema gap, adding semantic value beyond the bare schema definition.

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 the specific verb 'Get' and identifies the resource 'categories for a specific asset type on Polyhaven'. It clearly distinguishes this from sibling tools like search_polyhaven_assets or download_polyhaven_asset, which focus on searching or downloading assets rather than listing categories.

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 alternative asset-related tools, nor does it mention any exclusions or prerequisites. The sibling tools list includes several related operations, but the description does not help the agent decide when this category-listing tool is appropriate.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It states that the tool returns a message indicating availability, which is transparent for a simple status check. It does not explicitly say 'non-destructive' or 'read-only', but the name and wording imply that, and the return behavior is disclosed.

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

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

The description is two sentences, front-loaded with the action, and contains no waste. Every word contributes to understanding the tool's purpose and output.

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 parameters and an output schema present, the description is complete. It clearly states what the tool checks and what it returns, which is all an agent needs to select and invoke it appropriately.

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 baseline score is 4. The description does not need to explain parameter meanings, and the empty input schema confirms no parameters are required.

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: checking if PolyHaven integration is enabled in Blender. It uses a specific verb ('Check') and resource ('PolyHaven integration'), and the added return message detail ('Returns a message indicating whether PolyHaven features are available') makes the purpose unambiguous and distinct from sibling tools like get_polyhaven_categories or search_polyhaven_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?

The description implies usage context (a status check before using PolyHaven features) but provides no explicit guidance on when to use it versus alternatives, nor any exclusions or prerequisites. It is clear what the tool does, but not explicitly when to invoke 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?

With no annotations, the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only operation, but the description does not explicitly state that it does not modify the scene, nor does it mention failure modes or prerequisites (e.g., an active scene). It offers basic transparency but lacks depth.

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 action and resource, making it easy 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 (no parameters) and the existence of an output schema, the description is adequate to convey the core function. It could ideally mention that it returns information about the current scene, but that is already implicit in the wording, so it is complete enough for an agent to select and invoke 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 input schema has zero parameters, and the schema description coverage is 100% (trivially). The description correctly avoids explaining parameters. According to the rubric, 0 params gives a baseline of 4.

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 'Get detailed information about the current Blender scene' clearly specifies the action ('get') and the resource ('detailed information about the current Blender scene'), and it distinguishes itself from sibling tool get_object_info by focusing on the scene level.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions or references to sibling tools like get_object_info for object-level details, leaving usage context implicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It thoroughly explains the polling nature of the tool ('call this tool MULTIPLE TIMES'), status interpretation (SUCCESS, FAILED, etc.), typical response structure (pbr_model_url on success), and failure conditions. This goes well beyond what a basic description would cover.

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 clear sections (purpose, important notes, workflow, args, returns). Every sentence adds value: the first states the purpose, the second clarifies dependency, the third explains polling behavior, and the workflow provides actionable steps. No redundant or verbose content.

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 (asynchronous task status checking), lack of annotations, and presence of an output schema, the description is highly complete. It covers purpose, usage, behavioral details, parameter semantics, and response interpretation. The output schema handles return structure, so the description appropriately focuses on operational context.

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 clearly explains the single parameter (task_id), its purpose ('to check'), and its source ('obtained from create_3d_model_from_text'). However, it doesn't specify the expected format or constraints of task_id (e.g., string pattern, length), leaving a minor gap.

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

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

The description clearly states the specific action ('Get the status') and resource ('a 3D model generation task'), distinguishing it from siblings like create_3d_model_from_text (which starts tasks) and get_object_info (which checks objects). It explicitly mentions the dependency on create_3d_model_from_text, avoiding confusion with other task-related tools.

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

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

The description provides explicit guidance on when to use this tool (after create_3d_model_from_text, with the returned task_id) and when to call it repeatedly (until task completion). It outlines a complete workflow with status interpretation and alternatives for different outcomes, clearly differentiating it from other status-checking siblings.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Import') and return type ('Result message'), but lacks details on permissions, side effects (e.g., scene modification), error handling, or operational constraints like rate limits. 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 front-loaded with the core purpose, followed by clear sections for parameters and returns. It uses minimal sentences with zero waste, making it efficient and easy to parse for an 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 tool's complexity (a mutation with 1 parameter), no annotations, and an output schema (which covers return values), the description is partially complete. It explains the purpose and parameter but lacks behavioral context like side effects or usage guidelines, leaving gaps that could hinder agent selection.

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 parameter 'glb_url' and explains it as 'Download URL of the GLB model file', adding meaningful context beyond the schema's basic title. With 0% schema description coverage and only 1 parameter, this compensates well, though it could specify URL format or constraints.

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

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

The description clearly states the verb ('Import') and resource ('GLB model from URL into Blender scene'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_3d_model_from_image' or 'download_polyhaven_asset', which might also involve 3D model handling, so it misses full sibling distinction.

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., when importing vs. creating models), or exclusions, leaving the agent to infer usage from the purpose 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 full burden. It states 'modify an existing object,' implying mutation, but lacks critical behavioral details: whether changes are reversible, what permissions are needed, how errors are handled (e.g., if object doesn't exist), or if there are rate limits. For a mutation 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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a bulleted list of parameters. There's no wasted text, but the structure could be slightly improved by integrating parameter details more seamlessly rather than as a separate list.

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 5 parameters with 0% schema coverage and no annotations, the description is moderately complete: it covers the purpose and parameters. However, as a mutation tool, it lacks behavioral context (e.g., side effects, error handling). The presence of an output schema (not shown) reduces the need to explain return values, but overall completeness is adequate 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 0%, so the description must compensate. It lists all 5 parameters with brief explanations (e.g., 'Optional [x, y, z] location coordinates'), adding basic semantics beyond the schema's titles. However, it doesn't clarify units (e.g., radians for rotation), constraints (e.g., array length must be 3), or interactions between parameters, leaving gaps in understanding.

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

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

The description clearly states the verb 'modify' and resource 'existing object in the Blender scene,' making the purpose immediately understandable. It distinguishes from siblings like 'create_object' and 'delete_object' by specifying modification rather than creation or deletion. However, it doesn't explicitly differentiate from tools like 'set_material' or 'set_texture' that might also modify objects in different ways.

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., object must exist), exclusions (e.g., not for creating new objects), or comparisons to siblings like 'set_material' for material changes. The agent must infer usage from the name and parameter list 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 mentions 'Returns a list of matching assets with basic information,' which hints at read-only behavior and output format, but lacks details on pagination, rate limits, authentication needs, or error handling. This is insufficient for a search tool with no annotation coverage, resulting in 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 well-structured and concise, with three sentences that efficiently cover purpose, parameters, and returns. Each sentence adds value without redundancy, and it is front-loaded with the core functionality. There is no wasted text, making it easy 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 moderate complexity (2 parameters, no annotations, but with an output schema), the description is partially complete. It covers the purpose and parameters adequately, and the output schema likely handles return values, reducing the need for detailed output explanation. However, it lacks behavioral context and usage guidelines, leaving gaps in overall completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context: 'asset_type' is explained with allowed values (hdris, textures, models, all), and 'categories' is described as an 'optional comma-separated list.' This clarifies parameter usage beyond the schema's basic titles, though it could provide more detail on category formats or examples.

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 assets on Polyhaven with optional filtering.' It specifies the verb ('search'), resource ('assets on Polyhaven'), and scope ('with optional filtering'). However, it does not explicitly differentiate from sibling tools like 'download_polyhaven_asset' or 'get_polyhaven_categories', which reduces the score from 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 no guidance on when to use this tool versus alternatives. It mentions 'optional filtering' but does not specify scenarios, prerequisites, or exclusions. For example, it does not clarify if this should be used before downloading assets or as an alternative to browsing categories directly, leaving usage context implied at best.

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 mentions 'set or create' but doesn't clarify if this is a read-only or destructive operation, what permissions are needed, or how errors are handled. The description is minimal and misses key behavioral traits like side effects or response format.

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 a clear purpose statement followed by a bulleted parameter list. Every sentence adds value, and there's no redundant information. It could be slightly improved by front-loading more context, but it's efficient overall.

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 (3 parameters, no annotations, but has an output schema), the description is minimally adequate. It covers the basic action and parameters but lacks completeness in usage guidelines, behavioral details, and integration with sibling tools. The output schema helps, but the description should do more to compensate for missing annotations.

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

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

The description lists parameters with brief explanations, adding some meaning beyond the input schema, which has 0% description coverage. It clarifies 'object_name' as the target, 'material_name' as optional for use or creation, and 'color' as RGB values. However, it doesn't fully compensate for the schema gap, lacking details on defaults or interactions between parameters.

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: 'Set or create a material for an object.' It specifies the verb ('set or create'), resource ('material'), and target ('object'), making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'set_texture' or 'modify_object', which might handle similar operations.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, such as whether the object must exist, or when to choose this over tools like 'set_texture' or 'modify_object'. It only lists parameters without explaining usage scenarios.

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

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

With no annotations, the description must handle all behavioral disclosure. It explains the prerequisite (texture must be downloaded) and the return type (success/failure message), but it does not disclose potential side effects (e.g., overwriting existing materials) or detail failure conditions. This is adequate but not comprehensive.

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: a one-sentence purpose, a concise parameter list, and a return-value note. Every line earns its place with no redundant text, making it easy for an agent to parse.

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

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

For a simple two-parameter tool, the description covers all necessary context: the action, prerequisites, parameter semantics, and return type. The presence of an output schema further reduces the need to detail return values. It is complete for the tool's complexity.

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

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

The input schema has no parameter descriptions (0% coverage), so the description fully compensates by defining both parameters: object_name as 'Name of the object' and texture_id as 'ID of the Polyhaven texture to apply (must be downloaded first)'. This provides clear, actionable meaning beyond the raw schema.

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

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

The description clearly states the tool's function with a specific verb ('Apply') and resource ('previously downloaded Polyhaven texture to an object'), which distinguishes it from sibling tools like search or download. It directly addresses the action and target, leaving no ambiguity.

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

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

The phrase 'previously downloaded' implicitly establishes a prerequisite workflow (use after download_polyhaven_asset), providing clear context for when this tool is appropriate. However, it does not explicitly name alternatives or state exclusions, so it falls short of a full 5.

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