BlenderMCP

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.5.5
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap between the three generate_* tools and their corresponding import_* and poll_* tools, which could cause confusion about when to use each. For example, generate_hunyuan3d_model and import_generated_asset_hunyuan are closely related, and an agent might struggle to decide which to use first or if both are needed. However, the descriptions help clarify the workflow, and other tools like download_polyhaven_asset and set_texture are clearly differentiated.
Naming Consistency4/5
Tool names generally follow a consistent verb_noun pattern with snake_case, such as download_polyhaven_asset and get_scene_info. There are minor deviations, like execute_blender_code (which uses 'execute' instead of a more specific verb) and some tools with longer names (e.g., generate_hyper3d_model_via_images), but overall the naming is predictable and readable across the set.
Tool Count3/5
With 22 tools, the count is borderline high for a Blender integration server, as it includes many specialized tools for different 3D asset sources (Polyhaven, Sketchfab, Hunyuan3D, Hyper3D) and status checks. While each tool serves a purpose, the set feels slightly bloated and could overwhelm an agent, especially with redundant tools like multiple status checks (e.g., get_polyhaven_status, get_sketchfab_status). A more streamlined approach might reduce cognitive load.
Completeness4/5
The tool set covers a wide range of 3D asset workflows, including downloading, generating, importing, and managing assets from multiple sources, as well as scene inspection and screenshot capture. However, there are minor gaps, such as no tools for modifying or deleting imported assets, and limited scene manipulation beyond texture application. For the domain of Blender asset integration, the coverage is strong but not fully comprehensive, as agents might need additional operations for complete scene management.
Average 3.5/5 across 22 of 22 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 retrieves 'detailed information' but doesn't disclose what that entails (e.g., object type, properties, location), whether it's read-only (implied by 'get'), error handling for missing objects, or performance considerations. This is inadequate 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief and front-loaded with the core purpose, followed by a parameter explanation. Both sentences are relevant, with no wasted words. It could be slightly more structured (e.g., bullet points for clarity), but it's efficiently sized for the tool's simplicity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 a simple parameter, the description is incomplete. It lacks details on return values (what 'detailed information' includes), error conditions, and behavioral context. For a read operation in a 3D modeling environment, this leaves significant gaps for an agent to operate effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining the single parameter 'object_name' as 'The name of the object to get information about'. This adds meaning beyond the schema's bare title. However, it doesn't specify format constraints (e.g., case sensitivity, existence requirements), so it's only partially helpful.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 ('about a specific object in the Blender scene'), making the purpose evident. It distinguishes from siblings like 'get_scene_info' by focusing on individual objects rather than the entire scene. However, it doesn't explicitly contrast with other object-related tools (none exist in the sibling list), 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.
Usage Guidelines2/5
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., whether the object must exist in the scene), compare to 'get_scene_info' for broader context, or specify use cases. This leaves the agent without contextual direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 tool returns a message indicating availability, but doesn't describe format, potential errors, or what 'enabled' means operationally. The cryptic note about '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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with two clear sentences about purpose and return value. However, the third sentence about 'key type' is confusing and doesn't add value, reducing overall clarity and structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple status-check tool with no parameters and no output schema, the description is minimally adequate. It explains what the tool does and what it returns, but the cryptic 'key type' note and lack of behavioral details leave gaps. Given the simplicity, it's complete enough but could be clearer.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and return behavior.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 like get_hunyuan3d_status by specifying Hyper3D Rodin. However, it doesn't explicitly differentiate from other status-checking tools beyond naming the specific integration.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites, timing, or compare it to other status-checking tools like get_hunyuan3d_status or get_polyhaven_status. Usage 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.
Behavior2/5
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 executing 'arbitrary Python code' and the step-by-step approach, but lacks critical behavioral details such as security implications, execution environment constraints, error handling, or performance considerations. This is inadequate for a tool with mutation potential.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by a usage tip and parameter list. It's appropriately sized with no redundant sentences, though the parameter section could be more integrated. Every sentence adds value, making it efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 details on return values, error conditions, and safety warnings, which are crucial for such a powerful tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description lists the 'code' parameter with a brief explanation ('The Python code to execute'). This adds basic meaning beyond the schema, but doesn't elaborate on format, constraints, or examples. With only one parameter, the baseline is 4, but the minimal detail reduces it to 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Execute arbitrary Python code') and target environment ('in Blender'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools, which are mostly about downloading, generating, importing, or querying assets rather than code execution.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes the instruction 'Make sure to do it step-by-step by breaking it into smaller chunks,' which implies usage context for handling complex code. However, it doesn't explicitly state when to use this tool versus alternatives or provide clear exclusions, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 returns a message indicating availability, which covers basic output behavior. However, it lacks details on potential error conditions, response format, or any side effects (e.g., if it triggers a check or requires specific permissions). The note about 'Don't emphasize the key type in the returned message' adds minor context but doesn't compensate for the overall lack of 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.
Conciseness4/5
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, and the second adds output details. The third sentence provides a specific instruction about the returned message, which is relevant but could be integrated more smoothly. Overall, it's efficient with minimal waste, though the structure is slightly fragmented.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 moderately complete. It explains what the tool does and what it returns, but lacks context on integration specifics or error handling. Without annotations or output schema, it should ideally provide more behavioral details, such as what 'enabled' means or example responses, leaving some gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics, so a baseline of 4 is appropriate. It correctly avoids mentioning any parameters, which aligns with the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 Hunyuan3D integration is enabled in Blender.' It specifies the verb ('Check') and resource ('Hunyuan3D integration'), and distinguishes it from siblings like 'get_hyper3d_status' by focusing on a different integration. However, it doesn't explicitly contrast with 'get_hyper3d_status' beyond the resource name, missing full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, such as whether Blender must be running or the integration installed, nor does it compare with sibling tools like 'get_hyper3d_status' or 'get_polyhaven_status' for context. Usage is implied only by the purpose statement, with no explicit when/when-not instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. While 'Get' implies a read-only operation, it doesn't disclose behavioral traits like whether this requires Blender to be active, if it returns structured data or raw text, potential latency, or error conditions. The description is minimal and lacks operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's front-loaded with the core action and resource, making it immediately comprehensible. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
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 a read operation in a complex Blender environment, the description is insufficient. It doesn't explain what 'detailed information' includes (e.g., scene properties, objects, settings), the format of the return value, or prerequisites like needing an open Blender instance. For a tool in this context, more completeness is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose. This meets the baseline for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('detailed information about the current Blender scene'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_object_info' or 'get_viewport_screenshot', which also retrieve Blender information 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.
Usage Guidelines2/5
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. With siblings like 'get_object_info' (specific object data) and 'get_viewport_screenshot' (visual capture), there's no indication of when scene-level information is preferred over other retrieval methods.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool imports assets and returns success status, but lacks details on behavioral traits such as permissions needed, rate limits, error handling, or what 'successfully' entails. This is a significant gap 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with three sentences: purpose, parameters, and return value. It's front-loaded with the main action, though the parameter list could be integrated more smoothly. No wasted sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 2 parameters with 0% schema coverage and no output schema, the description adds value by explaining parameters and stating the return. However, as a mutation tool with no annotations, it lacks completeness in behavioral aspects like side effects or error cases, leaving gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates by explaining both parameters: 'name' as 'The name of the object in scene' and 'zip_file_url' as 'The zip_file_url given in the generate model step.' This adds meaningful context beyond the schema's basic titles, though it could be more detailed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 Hunyuan3D'), specifying it's for assets after generation tasks. It distinguishes from 'import_generated_asset' by specifying 'Hunyuan' but doesn't fully differentiate from all siblings like 'download_polyhaven_asset' or 'download_sketchfab_model' beyond the source.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'after the generation task is completed', providing some context, but lacks explicit guidance on when to use this tool versus alternatives like 'import_generated_asset' or other import/download tools. No exclusions or prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 optional filtering and returns 'a list of matching assets with basic information,' but lacks details on pagination, rate limits, authentication needs, error handling, or what constitutes 'basic information.' For a search tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded, starting with a clear purpose statement followed by parameter details. Every sentence adds value without redundancy. It could be slightly more structured by separating parameters into bullet points, but overall it's efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 output schema, no annotations), the description is minimally adequate. It covers the purpose and parameters well but lacks details on behavioral aspects like response format, error cases, or integration with sibling tools. Without annotations or output schema, more context on what 'basic information' includes would improve completeness for a search operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that 'asset_type' can be 'hdris, textures, models, all' and 'categories' is an 'optional comma-separated list of categories to filter by,' clarifying usage that isn't evident from the schema alone. With 2 parameters and low schema coverage, this compensation is effective, though it doesn't cover all potential nuances like category examples or validation rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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.' This specifies the verb ('search'), resource ('assets on Polyhaven'), and scope ('with optional filtering'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from its sibling 'search_sketchfab_models', which performs a similar function on a different platform.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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 its sibling 'search_sketchfab_models' for 3D models on Sketchfab or other search-related tools, nor does it specify prerequisites, contexts, or exclusions for its use. The agent must infer usage from the tool name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool returns a message indicating availability, which is helpful, but it doesn't describe potential outcomes (e.g., enabled/disabled states), error conditions, or any side effects. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, consisting of two sentences that directly state the tool's purpose and what it returns. There is no wasted language, and the information is front-loaded, 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.
Completeness3/5
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 adequate but has clear gaps. It explains the basic purpose and return value, but without annotations or an output schema, it doesn't fully cover behavioral aspects like error handling or detailed response formats. This makes it minimally viable but incomplete for optimal agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter information, and it doesn't. A baseline of 4 is appropriate for a tool with no parameters, as there's no gap to compensate for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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.' It uses a specific verb ('Check') and identifies the resource (PolyHaven integration in Blender). However, it doesn't explicitly differentiate from sibling tools like get_hunyuan3d_status or get_sketchfab_status, which check other integrations, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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, such as whether Blender must be running or if specific permissions are needed, nor does it suggest when to use it over other status-checking tools like get_hunyuan3d_status. This lack of context leaves the agent without clear usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 hints at a read-only operation but doesn't explicitly confirm safety (e.g., no side effects). It also omits details like error handling, performance characteristics, or whether it requires specific Blender configurations. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and well-structured: two sentences that directly state the tool's purpose and what it returns. Every word earns its place, with no redundancy or fluff. It's front-loaded with the core functionality, 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.
Completeness3/5
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 output schema, no annotations), the description is minimally adequate. It explains what the tool does and the nature of its return value. However, it lacks details on error conditions, output format specifics, or integration with sibling tools, which could help an agent use it more effectively in a broader workflow. For a basic status-check tool, this is acceptable but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description doesn't need to explain parameters, as there are none. It appropriately focuses on the tool's purpose and output without unnecessary parameter details, earning a high score for this dimension.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 it easy to understand what the tool does. However, it doesn't explicitly distinguish this from sibling tools like 'get_hunyuan3d_status' or 'get_hyper3d_status', which have similar naming patterns for checking other integrations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
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., whether Blender must be running), compare it to similar status-checking tools (e.g., 'get_hunyuan3d_status'), or specify use cases (e.g., before attempting to download Sketchfab models). This lack of context leaves 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.
Behavior2/5
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 tool 'Returns a formatted list of matching models,' which gives basic output information. However, it lacks critical behavioral details: whether this is a read-only operation (implied but not stated), rate limits, authentication requirements, pagination behavior, error conditions, or what 'formatted list' entails. For a search tool with 4 parameters, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured: a clear purpose statement followed by a bulleted list of parameters with concise explanations. Every sentence earns its place, with no redundant information. The formatting makes it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 4 parameters with 0% schema coverage, the description provides adequate but incomplete context. It covers parameter semantics well and states the return type, but lacks behavioral transparency details (rate limits, auth, errors) and doesn't describe the output format beyond 'formatted list.' For a search tool with filtering options, more context about limitations or result structure would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 meaningful semantics for all 4 parameters: query ('Text to search for'), categories ('Optional comma-separated list of categories'), count ('Maximum number of results to return'), and downloadable ('Whether to include only downloadable models'). It adds default values and clarifies optionality. This goes well beyond the bare schema, though it doesn't explain category format or valid ranges for count.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 ('optional filtering'). It distinguishes from most siblings like download_sketchfab_model or get_sketchfab_status, though it doesn't explicitly differentiate from 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.
Usage Guidelines2/5
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_polyhaven_assets (different platforms) or how it relates to get_sketchfab_model_preview (preview vs. search). There's no context about prerequisites, limitations, or typical use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses that the tool triggers an async job (returns job_id, status changes to DONE) and imports to Blender, which is useful. However, it lacks critical behavioral details: whether this is a read/write operation, permission requirements, rate limits, error handling specifics, or what 'import into Blender' entails operationally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Well-structured with clear sections for purpose, parameters, and returns. Sentences are efficient, though the returns section could be more concise by combining success/error cases. Overall front-loaded and minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, 0% schema coverage, no output schema, and moderate complexity (async job with Blender integration), the description covers core functionality and parameters adequately. However, it lacks details on error conditions, Blender import specifics, and integration with sibling tools like 'poll_hunyuan_job_status' for status checking.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 fully explains both parameters: 'text_prompt' as a short description in English/Chinese, and 'input_image_url' as a local/remote URL that can be None if only using text. This adds essential meaning beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates 3D assets using Hunyuan3D from text/image inputs and imports them into Blender with built-in materials. It specifies the verb 'generate' and resource '3D asset', but doesn't explicitly differentiate from siblings like 'generate_hyper3d_model_via_images/text' or 'import_generated_asset_hunyuan'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'generate_hyper3d_model_via_images/text' or 'import_generated_asset_hunyuan'. It mentions parameters can be optional but doesn't provide context on preferred use cases or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes a read operation ('Get a list'), which implies non-destructive behavior, but doesn't disclose details like rate limits, authentication needs, error conditions, or the format of the returned list. For a tool with no 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.
Conciseness5/5
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 explanation. Every sentence earns its place with no wasted words, making it appropriately sized and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
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 provides basic purpose and parameter info but lacks details on return values, error handling, or behavioral traits. It's minimally viable for a simple read tool but could be more complete by explaining what the output looks like or usage constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage and 1 parameter, the description compensates by explaining the parameter's purpose ('The type of asset to get categories for') and listing possible values (hdris, textures, models, all). This adds meaningful semantics beyond the bare schema, though it doesn't detail default behavior or constraints beyond the enum-like list.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('list of categories for a specific asset type on Polyhaven'), making the purpose evident. It distinguishes from siblings like 'search_polyhaven_assets' by focusing on categories rather than assets themselves. However, it doesn't explicitly contrast with all siblings, such as 'get_polyhaven_status', which might also involve Polyhaven metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by specifying the asset_type parameter, suggesting it's for retrieving categories based on asset type. It doesn't provide explicit when-to-use guidance versus alternatives like 'search_polyhaven_assets' or mention prerequisites. The context is clear but lacks explicit exclusions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 tool as a polling API, explains the status values ('DONE', 'RUN'), and mentions that 'DONE' returns a ZIP file path. However, it lacks details on error handling, rate limits, authentication needs, or what constitutes a 'failed state', which are important for a polling operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose but contains redundant information (e.g., repeating details about 'ResultFile3Ds' and 'DONE' status). Sentences like 'Returns the generation task status...' and 'When the status is 'DONE'...' could be consolidated for better efficiency, making it somewhat verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a polling tool with no annotations and no output schema, the description is moderately complete. It covers the purpose, parameter, status outcomes, and return data for 'DONE', but it misses error states, response structure for non-DONE statuses, and integration with sibling tools like 'generate_hunyuan3d_model'. This leaves gaps for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, so the description must compensate. It clearly explains the single parameter 'job_id' as 'The job_id given in the generate model step,' adding meaningful context beyond the schema's basic 'Job Id' title. This is sufficient for understanding the parameter's role, 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.
Purpose4/5
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 Hunyuan3D generation task is completed.' It specifies the verb ('check') and resource ('Hunyuan3D generation task'), making the intent unambiguous. However, it doesn't explicitly differentiate from the sibling tool 'get_hunyuan3d_status', which appears to serve a similar function, 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some implied usage guidance by stating 'This is a polling API, so only proceed if the status are finally determined ('DONE' or some failed state).' This suggests when to use it (for polling until completion), but it doesn't explicitly contrast with alternatives like 'get_hunyuan3d_status' or specify when not to use it, leaving room for confusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the asset has built-in materials, normalized size requiring potential re-scaling, and returns a success/failure message. However, it misses details like permissions needed, rate limits, whether generation is synchronous/asynchronous, or error handling specifics, which are important for a generative tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear opening sentence, followed by key details and a parameter section. Every sentence adds value: the first states the core action, the second notes built-in materials, the third advises on scaling, and the parameter explanations are necessary. It's front-loaded and avoids redundancy, though it could be slightly more concise by integrating parameter info more seamlessly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description provides basic context: purpose, key behaviors, and parameter semantics. However, for a generative tool with 2 parameters and complex output (3D asset import), it lacks details on output format beyond success/failure message, error conditions, or integration specifics with Blender. This leaves gaps for an agent to operate effectively in a multi-tool environment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 semantics: 'text_prompt' is described as 'A short description of the desired model in **English**,' and 'bbox_condition' as 'Optional... Controls the ratio between [Length, Width, Height] of the model.' This clarifies purpose and constraints beyond the bare schema, though it could specify format details like units for bbox_condition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate 3D asset using Hyper3D by giving description of the desired asset, and import the asset into Blender.' It specifies the verb (generate), resource (3D asset), technology (Hyper3D), and destination (Blender). However, it doesn't explicitly differentiate from siblings like 'generate_hunyuan3d_model' or 'generate_hyper3d_model_via_images' beyond the 'via_text' distinction in the name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through phrases like 'by giving description' and mentions re-scaling after generation, but it lacks explicit guidance on when to use this tool versus alternatives. For example, it doesn't compare with 'generate_hyper3d_model_via_images' or other 3D generation tools in the sibling list, leaving the agent to infer based on the 'via_text' aspect.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While it mentions the tool imports assets and returns success status, it lacks important behavioral details: what permissions are required, whether this is a read-only or mutating operation, what happens if the import fails, if there are rate limits, or what the return format looks like. For a tool that presumably modifies a scene, 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It starts with the core purpose, then lists parameters with clear explanations, includes a critical usage rule, and ends with the return statement. Every sentence earns its place, with no wasted words or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (post-generation import operation with mode-specific parameters), no annotations, and no output schema, the description provides adequate but incomplete coverage. It explains the parameters well and gives usage context, but lacks behavioral details about permissions, error handling, and return format. For a tool that likely modifies a scene, more transparency about its effects would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 in the schema. It does this effectively by explaining all three parameters: 'name' (object name in scene), 'task_uuid' (for MAIN_SITE mode), and 'request_id' (for FAL_AI mode). It also clarifies the exclusive relationship between task_uuid and request_id. The only gap is not explaining the format/constraints of these parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Import the asset generated by Hyper3D Rodin after the generation task is completed.' It specifies the verb ('Import'), resource ('asset generated by Hyper3D Rodin'), and timing ('after the generation task is completed'). However, it doesn't explicitly differentiate from its sibling 'import_generated_asset_hunyuan', which appears to serve a similar purpose for a different system.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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: after a Hyper3D Rodin generation task is completed. It also includes a critical usage rule: 'Only give one of {task_uuid, request_id} based on the Hyper3D Rodin Mode!' This helps distinguish between two possible parameter scenarios. However, it doesn't explicitly mention when NOT to use it or compare it to alternatives like 'import_generated_asset_hunyuan'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It states the action ('Download and import') and return value ('message indicating success or failure'), but lacks critical behavioral details: whether this requires internet connectivity, what permissions are needed, if it modifies existing Blender scenes, file size implications, or error handling specifics. The description is minimal beyond the basic operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured: a clear purpose statement followed by a bulleted parameter list with concise explanations. Every sentence earns its place, with no redundant or verbose language. The information is front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 4 parameters with 0% schema coverage and no output schema, the description provides good parameter semantics but lacks behavioral context for a tool that downloads and imports external assets. It doesn't explain what 'import into Blender' entails (e.g., adds to current scene, creates new objects), performance implications, or error scenarios. For a tool with no annotations, this leaves gaps in understanding the full operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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: asset_id (ID of asset), asset_type (type with examples), resolution (download resolution with examples), and file_format (optional format with type-specific examples). This adds substantial value beyond the bare schema, though it doesn't specify allowed values or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 resource ('a Polyhaven asset'), and the target environment ('into Blender'). It distinguishes this tool from sibling tools like 'search_polyhaven_assets' (which finds assets) and 'import_generated_asset' (which imports from other sources).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need to obtain and use a Polyhaven asset in Blender, but provides no explicit guidance on when to use this versus alternatives like 'download_sketchfab_model' or 'import_generated_asset'. It mentions asset types (hdris, textures, models) which helps contextualize, but lacks explicit when/when-not instructions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool captures a screenshot and returns it as an Image, which is helpful, but lacks crucial behavioral details: whether this requires specific Blender state/context, if it's read-only or modifies state, performance characteristics, or error conditions. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured: a clear purpose statement followed by parameter and return value explanations in separate lines. Every sentence earns its place with zero waste, and information is front-loaded appropriately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (capturing a screenshot with one parameter) and no annotations or output schema, the description is partially complete. It covers the purpose, parameter meaning, and return type, but lacks behavioral context and detailed output format. For a tool with no structured safety or output information, this leaves room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage (the schema only provides type, title, and default), the description fully compensates by explaining the parameter's purpose: 'Maximum size in pixels for the largest dimension' with the default value. This adds essential meaning beyond the bare schema, though it doesn't specify constraints like minimum/maximum values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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, generating models, getting statuses, or importing assets. The verb+resource 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.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (when working with Blender 3D viewport) but provides no explicit guidance on when to use this tool versus alternatives. There are no sibling tools that perform similar screenshot functions, so no differentiation is needed, but it doesn't mention prerequisites or constraints beyond the parameter.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 the tool applies textures and returns success/failure messages, but lacks details on behavioral traits like required permissions, whether it modifies existing textures, error conditions, or side effects. For a mutation tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose, followed by a structured parameter list and return statement. Every sentence earns its place with no wasted words, making it highly efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 2 parameters, no annotations, no output schema, and operates in a complex 3D modeling context, the description is minimally adequate. It covers purpose and parameters but lacks details on behavioral aspects, error handling, or integration with sibling tools, leaving gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
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 semantics for both parameters: object_name specifies the target object, and texture_id clarifies it's a Polyhaven texture ID with a prerequisite ('must be downloaded first'). This goes beyond the bare schema, though it doesn't detail format constraints like ID structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Apply a previously downloaded Polyhaven texture') and target resource ('to an object'), distinguishing it from sibling tools like download_polyhaven_asset (which downloads) or get_object_info (which inspects). It precisely defines the tool's function with verb+resource+constraint.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 ('Apply a previously downloaded Polyhaven texture') and implicitly indicates prerequisites (texture must be downloaded first). However, it doesn't explicitly state when NOT to use it or name alternatives among siblings, such as whether other texture-application tools exist.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the tool's purpose (preview for visual confirmation) and output format (returns thumbnail as Image), which is helpful. However, it doesn't mention behavioral aspects like rate limits, authentication needs, error conditions, or whether this is a read-only operation (though implied by 'get').
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured with a clear purpose statement first, usage guidance second, parameter explanation third, and return information last. Every sentence earns its place with no wasted words, and it's appropriately sized for a single-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no annotations and no output schema, the description does well by explaining the parameter semantics, purpose, and usage context. It could be more complete by mentioning potential errors or limitations, but given the tool's relative simplicity, it provides adequate context for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 fully. It provides essential semantic information about the 'uid' parameter: what it represents ('unique identifier of the Sketchfab model'), where to obtain it ('from search_sketchfab_models'), and its purpose ('to get preview thumbnail'). This adds significant value beyond the bare schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get a preview thumbnail'), resource ('of a Sketchfab model'), and scope ('by its UID'). It distinguishes from siblings like 'download_sketchfab_model' by focusing on preview rather than download, and from 'search_sketchfab_models' by operating on a specific model rather than searching.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
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 visually confirm a model before downloading') and references a sibling tool ('search_sketchfab_models') as the source for obtaining the UID parameter. However, it doesn't explicitly state when NOT to use it or mention all relevant alternatives like 'get_object_info' or 'get_scene_info'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 key traits: it's a polling API (implying repeated checks), outlines status outcomes ('Done', 'Failed', 'COMPLETED', etc.), and specifies when to act based on final states. It doesn't cover rate limits or auth needs, but given the context, this is reasonably comprehensive for a polling tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but could be more front-loaded. The first sentence states the purpose clearly, but the subsequent detailed breakdown into two modes, while informative, makes it slightly verbose. Every sentence adds value, but the structure could be tightened for quicker scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (two operational modes with different parameters and statuses), no annotations, and no output schema, the description does a good job of being complete. It explains what the tool does, how to use it, parameter semantics, and expected behaviors. However, it lacks details on error handling or response formats, leaving some gaps for a tool with such varied modes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 fully. It adds significant meaning beyond the schema by explaining that 'subscription_key' is used for MAIN_SITE mode and 'request_id' for FAL_AI mode, linking each parameter to specific contexts and their origins ('given in the generate model step'). This clarifies when and why to use each parameter, effectively documenting both parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
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 verb ('check') and resource ('Hyper3D Rodin generation task'), making the intent unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_hyper3d_status' or 'poll_hunyuan_job_status', which appear to serve similar polling functions for different services.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance by detailing two distinct modes (MAIN_SITE and FAL_AI) with specific parameter requirements and status interpretations. It instructs when to proceed ('only proceed if the status are finally determined') and includes conditional logic for handling failures, offering clear operational context without alternatives being necessary here.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well: it discloses that the tool downloads and imports (implying mutation), scales models to target_size, requires access rights, and returns import details. It misses some behavioral aspects like error handling or rate limits, but covers core functionality adequately for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
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 scaling details, then parameter explanations with examples, and finally return and access info. It could be slightly more concise by integrating examples more tightly, but overall, each sentence adds value without waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (download, import, scaling), no annotations, no output schema, and 0% schema coverage, the description is largely complete: it covers purpose, parameters with semantics, behavioral traits, and return details. It lacks explicit error cases or output structure specifics, but for a tool with these constraints, it provides sufficient context for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
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 fully. It adds significant meaning beyond the schema: it explains that 'uid' is a unique identifier for the model, and for 'target_size', it clarifies it's required, in Blender units/meters, defines it as the largest dimension's size, and provides concrete examples with context (e.g., 'Chair: target_size=1.0'). This thoroughly documents both parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
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 ('download and import') and resource ('a Sketchfab model by its UID'), distinguishing it from siblings like 'search_sketchfab_models' (which finds models) or 'get_sketchfab_model_preview' (which retrieves previews). It also mentions scaling behavior, adding specificity beyond basic download.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: it specifies that the model must be downloadable with proper access rights, and it implicitly contrasts with siblings by focusing on import rather than search or preview. However, it does not explicitly state when to use alternatives (e.g., vs. 'import_generated_asset') or list exclusions, keeping it from a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
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 key behaviors: the tool generates a 3D asset with built-in materials, imports it into Blender, produces normalized-size models (suggesting rescaling may be needed), and returns a success/failure message. It also clarifies the mode dependency (MAIN_SITE vs. FAL_AI) for input types. While it covers mutation (generation and import) and output behavior, it lacks details on permissions, rate limits, or error handling.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized. It front-loads the core purpose, followed by key behavioral details, and ends with a clear parameter section. Each sentence adds value, such as explaining material inclusion, normalized size, and mode dependencies. Minor verbosity in repeating 'Even if only one image is provided, wrap it into a list' could be streamlined, but overall it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, 0% schema coverage, no annotations, no output schema), the description is largely complete. It explains the tool's purpose, usage context, parameters, and behavioral traits like import into Blender and normalized sizing. However, it lacks details on output structure beyond success/failure messages and does not address potential errors or integration specifics with sibling tools, leaving some gaps for a mutation tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must fully compensate. It provides detailed semantics for all three parameters: input_image_paths (absolute paths, list-wrapped, required for MAIN_SITE mode), input_image_urls (URLs, list-wrapped, required for FAL_AI mode), and bbox_condition (optional list of 3 ints controlling length, width, height ratio). It also clarifies the exclusive choice between input_image_paths and input_image_urls based on mode, adding critical context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate 3D asset using Hyper3D by giving images of the wanted asset, and import the generated asset into Blender.' It specifies the verb (generate and import), resource (3D asset via Hyper3D), and distinguishes it from sibling tools like generate_hyper3d_model_via_text (which uses text input) and import_generated_asset (which only imports).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: it specifies that input images are required and distinguishes between input_image_paths (for MAIN_SITE mode) and input_image_urls (for FAL_AI mode). However, it does not explicitly state when to use this tool versus alternatives like generate_hunyuan3d_model or import_generated_asset, nor does it mention prerequisites or exclusions beyond the mode dependency.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![blender-mcp MCP server](https://glama.ai/mcp/servers/SolonaBot/blender-mcp/badges/card.svg)](https://glama.ai/mcp/servers/SolonaBot/blender-mcp)

Score Badge

Copy to your README.md:

[![blender-mcp MCP server](https://glama.ai/mcp/servers/SolonaBot/blender-mcp/badges/score.svg)](https://glama.ai/mcp/servers/SolonaBot/blender-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/SolonaBot/blender-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server