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

Annotations already indicate readOnlyHint=false and destructiveHint=false, so the mutation is expected. The description adds the return format (success/message/data) but does not disclose side effects, failure modes, or whether the collection is created if missing. This is adequate given the simple operation, 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 concise and well-structured, with a one-line summary, a return format section, and a code example. No redundant text; every element serves a purpose.

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

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

The tool is simple (2 string params, no nested objects) and has an output schema, so little beyond the basics is needed. However, the description could be more complete by clarifying the relationship to existing collections/objects and any error behavior, especially given the large set of sibling tools in the Blender domain.

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

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

Schema description coverage is 0%, and the description does not explain the parameters beyond their names. 'collection_name' and 'object_name' are self-explanatory at a high level, but no details are given about what constitutes a valid name, whether the object must already exist, or how collections are referenced. The example shows sample values but adds no semantic depth.

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?

Description clearly states 'Add an object to a collection' with a specific verb and resource. It distinguishes from sibling 'create_collection' (which creates collections) and 'construct_object' (which creates objects), though it does not explicitly mention the relationship to existing objects/collections.

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 on when to use this tool versus alternatives. It does not mention prerequisites (e.g., collection must exist), nor does it contrast with related tools like 'create_collection' or 'manage_object_repo'. The example provides usage context but not decision criteria.

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?

It discloses the looping behavior and the max_steps stopping condition, which is useful given annotations are all false. However, it does not mention potential side effects on the Blender scene, what 'capability probes' entail, or resource/permission implications, leaving the agent under-informed for a tool that executes arbitrary workflows.

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

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

The description is compact at two sentences, with the main action front-loaded. The reference to 'FastMCP 3.1 SEP-1577 sampling' adds jargon, but the text remains focused and readable.

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

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

With an output schema present, return-value explanation is not needed. Yet the tool is complex and has an available_operations parameter not mentioned in the prose; also absent are side-effect warnings, failure behavior, and differentiation from many similar Blender workflow siblings. The description is adequate but not fully complete.

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

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

Schema coverage is 100% and each parameter already has a meaningful description. The prose does not add further semantic value to workflow_prompt, max_steps, or available_operations, so a baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Execute autonomous multi-step Blender workflows'. It distinguishes this tool from siblings like 'blender_workflow' by emphasizing the agentic, looped, sampling-driven behavior.

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

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

The description clearly conveys the context for use: autonomous, multi-step 3D workflows where the client LLM plans and loops. It does not provide explicit when-not-to-use guidance or name alternatives, so it misses the top bar, but the intended use case is clear.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context about using the blender-expert SKILL.md as system context and the fallback mechanism via ctx.sample()/Ollama, providing insight into operational behavior.

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

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

The description is compact and well-structured: first sentence states purpose, second explains system context, third details model fallback. Every sentence adds distinct value with no redundancy.

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

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

For a chat tool with a simple schema, full annotation coverage, and an output schema, the description is sufficient. It explains both functionality and operational details, though it could benefit from mentioning limitations or scenarios where other tools are preferred.

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 fully covers the single 'message' parameter with a clear description. The tool description does not add parameter-specific details, but none are necessary given the schema's completeness.

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: 'Chat with the Blender AI assistant' and 'Provides natural-language help with Blender operations.' It identifies it as a conversational tool, distinguishing it from action-oriented siblings like script_execute. However, it doesn't explicitly differentiate from the similarly named conversational_blender_assistant.

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 explicit when-to-use guidance or alternative references are provided. The description implies it is for natural-language help but does not explain when to choose it over blender_help or other assistant-like tools.

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

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

Annotations provide no safety hints (all false), so the description carries the burden. It discloses that list requires Blender and describes operations, but doesn't specify side effects like network access, file deletion, or config changes. It gives basic behavioral context 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 structured with an introductory purpose sentence and a bulleted operation list. It is slightly long but information-dense; no wasted words. The redundant list_addons/list_installed pair is minor.

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

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

With a complex operation set and output schema present, the description covers all main operation categories and parameter mappings. It notes Blender requirement and known registry, but could mention enable_on_install behavior or error scenarios. Still nearly complete for selection and invocation.

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

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

Schema provides descriptions for all parameters (100% coverage), but the description enriches them by mapping operations to specific parameters (e.g., install_from_url uses addon_url, install_addon uses addon_path). It also clarifies 'install_known' and 'search' semantics beyond the schema.

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

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

Description clearly states the tool manages Blender addons and enumerates specific operations (list, install, uninstall, enable/disable, search, info). It explicitly distinguishes itself from sibling manage_blender_addons with 'Prefer this tool over manage_blender_addons.'

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

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

Explicitly advises preference over manage_blender_addons, which serves as an alternative. The operation list provides clear context for which action to invoke, mapping operations to parameters.

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

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

Annotations are all false, so the description carries the transparency burden. It discloses that external AI backends are used, that API keys are required, and that the generate operation involves polling and import. It also details the return format and gives an example. This goes beyond basic mutation info, though it doesn't mention potential network delays, costs, or failure modes.

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

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

The description is well-structured with sections for backends, operations, return format, and examples. It front-loads the main purpose, then provides necessary operational details without unnecessary fluff. Every section contributes useful information.

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

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

Given the tool's complexity (multiple backends, operations, API keys), the description covers key aspects: backends, env vars, operations, return format, and a usage example. It doesn't detail every parameter or error handling, but with the input schema present and an output schema, it's reasonably complete for an AI agent to use effectively.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only shows an example using operation and prompt, and the operations list implies prompt/image_path. However, backend, object_name, poll_timeout, and output_format are not described. The agent must infer their meanings from names and defaults, which is insufficient for a 7-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 opens with a specific and clear statement: 'Generate 3D meshes via external AI backends and import into Blender.' It also enumerates distinct operations (generate, list_backends), which further clarifies its scope. This clearly distinguishes it from sibling tools like blender_mesh or blender_import that handle mesh operations or imports without AI generation.

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

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

The description communicates when to use the tool: when you need AI-based 3D generation from text/image with backend options, and it explains backend configuration via environment keys. It doesn't explicitly exclude alternatives or name sibling tools, but the context is clear enough that an agent would know to use this for AI generation versus manual modeling/import.

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

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

The description explicitly labels 'clear_animation' as '(destructive)', but the annotations declare destructiveHint: false. This is a direct contradiction. The annotation system is designed to convey this safety information, and the description contradicts it, which is a serious inconsistency.

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

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

The description is well-structured with clear category headers and bullet lists, making it navigable for a complex 32-parameter tool. However, it includes an unnecessary 'PORTMANTEAU PATTERN RATIONALE' paragraph that adds meta-narrative rather than operational guidance, and the overall length is verbose.

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 high complexity (32 parameters, 21 operations), the description provides a comprehensive overview of all operation categories, which is highly useful for orientation. An output schema exists, so return values are covered. Minor gaps remain, such as not describing side effects for baking operations or constraint behaviors, but overall it is complete for a tool of this scale.

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

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

Schema description coverage is 100%, with each parameter already thoroughly documented in the input schema (e.g., ranges, defaults, required-for mapping). The tool description adds no extra parameter semantics beyond grouping operations by category, which is marginal value, so the baseline of 3 is appropriate.

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

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

The description clearly states 'Comprehensive animation system for Blender supporting keyframes, shape keys, actions, constraints, and baking' and enumerates 17 operations across categories, providing a specific verb+resource. However, it does not explicitly differentiate from sibling tools like blender_rigging or blender_shapekeys, though the portmanteau rationale explains the consolidation rationale.

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

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

The description implies usage by listing operation categories (e.g., Basic Animation, Shape Keys, Constraints) and notes when certain parameters are required for specific operations. However, it does not provide explicit when-to-use vs. alternatives guidance, nor does it mention exclusions or when to prefer sibling tools such as blender_shapekeys or blender_rigging.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds value by specifying the return format (dict with success, message, data) and the intent to reduce hallucinated API calls. This is consistent with annotations and adds context beyond them.

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

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

The description is compact and well-structured with examples and a return format section. While the Python code example is somewhat redundant, it doesn't waste space. Overall it is appropriately sized and front-loaded with purpose.

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

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

For a simple lookup tool with an output schema, the description includes return format and usage intent, which is good. However, the unclear role of 'search' leaves a gap in completeness, making it not fully self-sufficient.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'identifier' parameter through examples, but the 'search' parameter is never mentioned or clarified. This leaves significant ambiguity for a two-parameter tool, and the description fails to fully compensate for the schema gap.

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

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

The description clearly states the tool's function: 'Look up Blender Python API documentation for an identifier.' It provides concrete examples (Mesh, bpy.types.Mesh, bpy.ops.mesh.primitive_cube_add) that illustrate scope. This distinguishes it from sibling tools that generate scripts or manipulate Blender scenes.

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

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

The description explicitly says 'Use before writing bpy scripts to reduce hallucinated API calls,' which gives clear context on when to use. It does not mention when not to use or alternatives, but the primary use case is well-stated.

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

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

Annotations already declare readOnlyHint false and destructiveHint false, so the tool is known to mutate state but not destroy it. The description adds that it 'merges materials and textures' and 'reduces draw calls,' which gives some behavior context. However, it does not disclose potential side effects like modification of existing materials or assets, reversibility, or whether it changes the scene permanently. This is a moderate level of 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 two sentences long, front-loaded with the core purpose, and every sentence is informative. It avoids fluff and clearly communicates the tool's value proposition.

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 (11 parameters, output schema, four operation types), the description provides a high-level use case and motivation but does not detail the different operations or typical workflows. However, the rich schema and annotations fill most gaps, so only a slight deduction is warranted.

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

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

Schema description coverage is 100%, meaning all 11 parameters have detailed descriptions in the schema. The tool description itself adds no parameter-level details beyond the schema, so it meets the baseline but does not enhance parameter understanding. No gaps to compensate.

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: 'material and texture atlasing for VR performance optimization' and 'Reduces draw calls by intelligently merging materials and textures.' It uses specific verbs and identifies the resource, but does not explicitly distinguish itself from sibling tools like blender_materials or blender_textures, so it falls short of a perfect 5.

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

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

The description provides clear usage context: 'critical for mobile VR performance on Quest and similar devices.' This implies when to use the tool (VR optimization scenarios) but does not explicitly mention alternatives or situations where it should not be used, so it scores just below the 5 threshold.

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

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

Annotations are all false, so the description carries the burden of disclosing side effects. It does not state whether files are overwritten, whether a Blender session is required, or any limitations. The operations imply file writes and modifications, but no explicit behavioral disclosure is provided.

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

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

The description is appropriately concise: an intro, a three-item bullet list, a return format line, and a code example. It is well-structured and front-loads the main purpose, with no unnecessary verbosity.

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 10 parameters and three distinct operations, the description is too sparse. It lacks per-operation parameter mapping, prerequisites, and edge-case behavior. The standard return format and output schema existence do not compensate for the missing operational detail.

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

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

With 0% schema coverage, the description must compensate. It explains 'pattern' defaulting to *.png and 'name_pattern' for export, but leaves unclear key parameters like width/height, source_format/target_format, and output_dir. The example demonstrates input_dir usage, but many params remain semantically opaque.

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 'Batch image and mesh export operations' and enumerates three specific operations (resize, convert, export), which defines a concrete scope. It differentiates from siblings like blender_export by focusing on batch and multi-type operations, though it doesn't explicitly contrast each mode.

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 explicit guidance on when to use this tool versus alternatives is given. The name implies batch use, and the operation list suggests scenarios, but there is no mention of exclusions or when to prefer a sibling like blender_export or script_execute.

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

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

Annotations are all false (readOnlyHint=false, destructiveHint=false, etc.), so the description itself must disclose behavioral traits. It only lists operations without explaining side effects, such as modifying the current scene, creating new objects, or affecting the active camera state. For example, 'Create a new camera' does not state that it adds a camera to the scene or require existing context.

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, front-loaded with the core purpose, and uses a bulleted list for operations. Every sentence contributes useful information, and there is no redundant text.

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?

An output schema exists, so return values are adequately documented elsewhere. However, the description lacks guidance on which parameters apply to each operation, which is important given 10 parameters and 3 operations. For instance, it doesn't explain that camera_name is needed for set_active_camera. This is a clear gap in 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 100%, so baseline is 3. The description adds some value by implying which parameters are relevant for each operation (e.g., set_camera_lens uses lens and sensor_width), but it does not clarify which parameters are required per operation. The parameter descriptions in the schema already cover individual meanings.

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

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

The description clearly states the tool's purpose with a specific verb and resource ('Create and control cameras in Blender scenes') and enumerates three distinct operations via the operation parameter. This differentiates it from siblings like blender_scene or blender_lighting, which target other aspects of Blender.

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

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

The description provides clear usage context by explaining that multiple operations are supported and listing them. While it does not explicitly name alternatives or exclusions, the camera-specific focus makes it evident when to use this tool. However, it could be improved by contrasting with other scene tools.

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

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

Annotations are all false, providing no safety profile. The description only gives surface-level operations (e.g., 'add a compositor node') without disclosing side effects, required Blender state, or reversibility. It does include the return format for success/message/data, but that's not behavioral context.

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

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

The description is well-structured with a bullet list, return format section, and example. It is concise and scannable, though the 'Operations' list could be slightly more compact if parameters were documented elsewhere.

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 13 parameters, 4 operations, no schema descriptions, and no annotations, the description falls short. It provides an overview and an example but omits parameter semantics, per-operation prerequisites, and broader Blender context needed to invoke it reliably.

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

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

Schema description coverage is 0%, and the description does not map any of the 13 parameters to operations. Some parameters are inferable (e.g., from_node/to_node for connect_nodes) but not explicitly documented, leaving users to guess the roles of glow_size, use_sequencer, etc.

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 handles 'Compositor graph operations for post-processing' and enumerates specific sub-operations (enable, add_node, connect_nodes, glow) with short explanations. While it doesn't explicitly contrast with sibling tools, the compositor focus distinguishes it from other Blender 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 implies usage for post-processing via the opening line and provides a simple example. However, it lacks explicit guidance on when to choose this tool over siblings like blender_render or blender_shaders, and does not explain when to use each sub-operation beyond their brief descriptions.

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

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

Description notes 'requires url' and 'optionally import into scene', adding some behavioral context. But annotations are all false and provide no safety hints, so the description carries the burden; it doesn't disclose potential side effects of importing into the scene or what happens on failure.

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

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

Two paragraphs with a structured operation list. The term 'portmanteau' is distracting and unexplained, but the overall text is compact and includes only the essentials.

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

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

The description covers the two operations and their key requirements. With an output schema present and fully documented parameters, it is complete enough to guide usage; it lacks explicit failure behavior, but that is likely handled by the output schema.

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

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

Schema descriptions cover all parameters (100%), providing a solid baseline. The description clarifies that 'operation' switches between download and info and that 'url' is expected for download, but adds no new syntax or format details beyond the schema.

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

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

Clearly states it downloads from URL and optionally imports, or provides file format info. Distinguishes from sibling import tools by emphasizing the URL source and offering a distinct info operation.

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 operation list clearly indicates when to use download vs info, and the 'requires url' note implies the precondition for download. However, it does not explicitly exclude alternatives like blender_import for local files, so there's clear context but no direct when-not 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?

Annotations provide no behavioral hints (all false), so the description carries the full burden. It discloses the return format but does not mention file system effects, overwrite behavior, or prerequisites like a running Blender instance. Since this tool writes files, the lack of any behavioral disclosure beyond operations 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.

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

The description is well-structured with a short intro, a bulleted list of operations, and an example. It is concise and free of excess verbiage, though the example code block and return format section add some length.

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 9 parameters and a nontrivial set of operations, the description is incomplete. It omits parameter semantics, does not explain platform preset differences, and does not mention limitations or requirements. The output schema covers return format, but overall the description leaves significant gaps for a tool of this complexity.

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

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

Schema coverage is 0%, and the description only illustrates 'operation' and 'output_path' via an example, leaving other parameters (global_scale, apply_transforms, include_materials, etc.) unexplained. While the operation list adds some value, it does not compensate for the undocumented parameters, which are critical for effective use.

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: 'Export Blender scenes and objects to interchange and game-engine formats.' It lists specific operations (e.g., export_gltf, export_fbx, export_unity) that distinguish it from siblings like blender_import and blender_render. The verb 'Export' is specific and the resource is well-defined.

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

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

The description provides clear context on when to use the tool (exporting scenes/objects to various formats), which is implied by the operation list and example. However, it does not explicitly state when not to use it or mention alternatives like blender_import, so it lacks explicit exclusion guidance.

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

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

With all annotation hints set to false (readOnly, idempotent, destructive), the description must disclose behavioral traits, but it does not. It does not mention whether the tool exports files, modifies the scene, creates presets, or has side effects. The operation parameter indicates multiple modes, but the description leaves the agent unaware of these behaviors.

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 front-loaded, with two sentences that communicate the core purpose without jargon or fluff. It earns its place, though it lacks structure (e.g., no bullets or operation list) that might aid scannability.

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

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

The tool is complex with 13 parameters and multiple operations (export, validate, get presets, create custom), but the description does not mention these operations or how the tool fits into a broader workflow. The output schema exists, so return values are covered, but the overall context of what the tool actually does beyond 'handling differences' is incomplete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds some high-level context by referencing scale, format, and bone limits, which loosely maps to check_scale, check_bones, and platform settings, but it does not provide detailed parameter semantics beyond what the schema already offers. Overall, the schema carries the load.

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

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

The description clearly identifies the tool as providing platform-specific export presets for VR avatar deployment, mentioning specific platforms (VRChat, Resonite, Unity) and critical aspects (scale, format, bone limits). This distinguishes it from general export tools like blender_export, though it does not explicitly contrast with siblings.

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

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

The description gives clear context for when to use the tool: when deploying avatars to VR platforms and needing to handle platform-specific differences. It implies usage scenarios but does not provide explicit when-not-to-use guidance or mention alternatives, so it falls just short of a 5.

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

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

Annotations provide no safety hints (all false). The description only says 'in Blender' and 'create', without disclosing side effects, whether it modifies the current scene, or any permissions needed. No additional behavioral context is provided.

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 bullet list of operations, front-loading the core purpose. It avoids unnecessary prose, though it could have added brief parameter guidance without becoming verbose.

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 high complexity (22 parameters, many operation-specific) and low schema coverage, the description is incomplete. It does not explain how operation selection affects parameters, room creation specifics, or any output behavior. An output schema exists, but that does not cover usage semantics for each operation.

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

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

Schema description coverage is only 27%, so the description must compensate for poorly documented parameters. It does not explain which parameters apply to which operation, nor does it add meaning beyond listing operation values. This leaves many type-specific parameters (e.g., bed_type, has_door) ambiguous.

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 creates furniture and complex objects in Blender, with a specific verb and resource. Listing supported operations (chairs, tables, beds, sofas, etc.) distinguishes it from sibling tools by targeting a specific object category.

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

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

The description implies usage by listing supported operations, so an agent knows this tool is for furniture creation. However, it lacks explicit guidance on when to use this tool versus alternatives like construct_object or blender_mesh, and does not mention exclusions or prerequisites.

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

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

Annotations are all false, so no safety profile is provided. The description lists mutating operations (e.g., assign_modifier, add_node) but does not disclose side effects such as modifying the Blender scene, requiring an open project, or potential failure modes. The return format is mentioned but redundant given the output schema.

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

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

The description is well-structured with a bullet list of operations, a return format note, and an example. It is concise and front-loaded, though the return format section is redundant since an output schema exists.

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

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

The tool is complex with 15 parameters and 6 distinct operations, but the description only lists operations without explaining operation sequences (e.g., create_group before add_node), parameter dependencies, or preconditions. The example covers only one operation, leaving significant operational gaps.

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

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

With 0% schema description coverage for 15 parameters, the description must compensate, but it only partially does. The operation names hint at relevant parameters (e.g., connect_nodes implies from_node/to_node) and the example uses group_name, but there is no explicit mapping of parameters to operations or clarification of required vs. optional fields.

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

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

The description clearly defines the tool as 'Geometry Nodes graph operations (procedural modeling)' and lists six specific operations (create_group, add_node, etc.), distinguishing it from sibling tools like blender_modifiers or blender_shaders. The enumerated operations make the purpose concrete and actionable.

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

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

The description provides clear domain context ('Geometry Nodes graph operations') and an example call, which implies usage. However, it does not explicitly mention when to choose this tool over alternatives or state any exclusions. This meets the 'clear context, no exclusions' level.

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

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

The description lists 'delete_strokes: Remove strokes from a GP frame' which is a destructive behavior, yet annotations declare destructiveHint=false. This contradicts the annotation's implication that the tool is not destructive. No other behavioral context (e.g., side effects, prerequisites) 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 well-structured with a clear rationale header and a bulleted operation list. It is somewhat long but each line conveys a distinct operation, so the length is justified. The use of markdown makes it scannable.

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 (27 params, 12 operations), the description provides a solid overview but does not fully explain prerequisites or operation-specific parameter requirements. However, the input schema and output schema cover many details, making the description sufficient for selection and basic invocation.

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

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

Schema coverage is 100% with each parameter already describing its 'used by' operation, so the baseline is 3. The description adds value by grouping operations into a coherent list, giving agents a high-level understanding of how parameters fit together across the 12 operations.

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 consolidates 12 Grease Pencil operations and provides an explicit list of operations, each with a brief verb+resource description. This distinguishes it from sibling tools focused on mesh, materials, or other Blender domains, leaving no doubt about its purpose.

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 through its operation list ('Use for Grease Pencil 2D animation operations') but does not explicitly mention alternatives or when not to use. It names no sibling tools or exclusions, so guidance is present but indirect.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds useful behavioral detail by explaining what each operation does and which parameters it consumes, going beyond the raw schema. It doesn't cover edge cases or error behavior, but for a read-only help tool, this is not 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 about 120 words and structured as a clear bullet-like list. The first sentence provides a concise overview, and each operation line is purposeful and directly informative. No redundant or filler language.

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

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

The tool has 5 operations and 6 optional parameters, and the description covers every operation with its parameter mapping. Since an output schema exists, return-value details are not needed. The description fully addresses the tool's scope as a help/meta utility, making it complete for an agent to invoke correctly.

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

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

Although schema coverage is 100%, the schema's parameter descriptions are terse and generic (e.g., 'For help - specific function name'). The description significantly enriches semantics by linking operations to parameters, e.g., 'help: Comprehensive help... (use function_name, category, detail_level)' and 'list_tools: List all tools, optionally filtered by category'. This mapping is the key value and is not present in the schema.

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

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

The description opens with 'Get help, list tools, search, tool info, or categories', clearly stating the tool's five distinct operations. It distinguishes itself from sibling tools by being the meta-help/utility tool, not a specific Blender feature.

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

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

The description explicitly maps each operation to its relevant parameters, e.g., 'search: Search tools by name or description (use query)' and 'tool_info: Detailed info for one tool (use tool_name)'. This provides clear usage context within the tool, though it does not explicitly contrast it with sibling tools like blender_api_docs. Still, the operations define their own usage sufficiently.

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

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

Annotations only contain false flags, so the description carries the burden. It adds useful context like automatic STEP/STP conversion with Mayo/FreeCAD/online tools and direct integration with robotics-mcp CAD converter, but it does not disclose side effects on the scene or potential failure modes.

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

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

The description is well-structured with a front-loaded purpose statement, bullet lists for operations and CAD features, and no redundant or filler content. Each line adds meaningful detail.

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

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

Given the tool's complexity (10 parameters, output schema exists), the description covers operations and CAD specifics adequately. It does not mention prerequisites like an active Blender session, but the output schema and detailed operation list make it sufficiently complete for an agent to select and invoke.

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

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

Schema coverage is high (90%), but the description enriches the operation parameter by enumerating possible values (import_[format], import_cad, link_asset) and explains the purpose of mesh_quality, cad_scale_factor, and cad_conversion_tool in the CAD features section.

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 'Import 3D files into Blender scenes' and elaborates with specific operations (import_[format], import_cad, link_asset). This distinguishes it from related tools like blender_export and provides a clear scope.

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 lists operation types within the tool but gives no explicit guidance on when to use this tool versus alternatives such as import_cad_file or blender_export. There are no exclusions or comparisons to 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?

Description discloses async behavior ('returns job_id immediately'), cancel semantics, and the standard return format (success, message, data). This adds meaningful context beyond the annotations, though it omits details like error handling or whether cancel truly kills remote jobs.

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?

Well-organized with a brief summary, bulleted operations, return format, and a single example. Every section serves a purpose and there is no redundant or filler 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?

Covers the core use case, operations, return format, and a practical example, making the tool largely self-contained. The few undocumented parameters prevent a perfect score, but overall it provides enough context for an agent to invoke it correctly.

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

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

The operations list and example clarify the 'operation' and 'script' parameters, but the remaining parameters (limit, job_id, timeout, script_name, prefer_session) are not explained. With schema description coverage at 0%, the description only partially compensates for the lack of structured documentation.

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

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

Description explicitly states 'Async job queue for long-running Blender Python scripts' and lists the four operations (submit, status, list, cancel), making its purpose unmistakable. This clearly distinguishes it from synchronous script execution and other Blender-specific siblings.

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 'long-running' qualifier and examples (renders, bakes, sims) indicate when to use this queueing tool. However, it does not explicitly mention alternatives like script_execute or state when not to use it, leaving the exclusion guidance 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 annotations all false (readOnlyHint=false, destructiveHint=false, etc.), the description carries the burden of disclosing behavior. It states operations such as 'Generate directional sunlight', 'Create point light', and 'Modify properties of existing lights', clearly indicating mutating effects. It also notes operation-specific parameters like spot_size and shadow_soft_size, adding context beyond the annotations.

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 starts with a 'PORTMANTEAU PATTERN RATIONALE' paragraph that explains tool design philosophy rather than usage. While the subsequent operation breakdown is well-structured with bullet points, the meta rationale adds length without helping an agent select or invoke the tool, making it less concise than optimal.

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 7 operations and 11 parameters, the description covers all operations and indicates which parameters apply to each. It implicitly communicates that it operates within Blender, consistent with sibling tools. Given the output schema exists, the lack of return-value details is acceptable. It does not mention prerequisites like an active Blender session, but this appears to be common across the sibling set.

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 100% coverage with detailed descriptions for all 11 parameters, including usage notes like 'Only used for: create_area'. The description groups parameters by operation (create_* vs setup_* vs adjust_light), which reinforces the mapping but does not add materially new semantics beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a 'Professional lighting system for Blender' and enumerates seven distinct lighting operations (create_sun, create_point, create_spot, create_area, setup_three_point, setup_hdri, adjust_light). This separates it from sibling tools like blender_camera or blender_render by focusing specifically on lighting.

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

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

The description implies this is the consolidated tool for all lighting tasks, explaining that it consolidates 7 operations to prevent tool explosion. However, it does not explicitly state when to use this over alternatives or list exclusions, leaving usage guidance implied rather than explicit.

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

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

Annotations already establish readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds operational behavior by describing what each operation does, including the stats output (total entries, time range, level distribution), which goes beyond the annotations without contradicting them.

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

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

The description is compact, starting with a clear one-sentence purpose and using a bulleted list for operations. Every sentence contributes meaning, with no 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 read-only nature, full schema coverage, and presence of an output schema, the description sufficiently explains the tool's functionality and parameter applicability. It does not discuss limitations or integration details, but these are not critical for a well-annotated read-only log 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 100% parameter description coverage, so baseline is 3. The description adds value by explicitly grouping parameters under 'view' and 'stats', clarifying which parameters apply to which operation and what the stats operation returns, which the schema does not fully convey.

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 'View recent logs or log buffer statistics' with a specific verb and resource. It then details two distinct operations (view and stats), making the tool's purpose unambiguous and distinguishable from sibling tools like show_logs_app.

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 operation-specific parameter groupings (view vs stats) but does not explicitly state when to use this tool instead of siblings such as show_logs_app or blender_status. There are no alternative/exclusion statements, so guidance is only implied.

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

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

The description says 'create and manage' which implies modifications to the Blender scene, but it does not disclose side effects, required permissions, reversibility, or what gets destroyed/changed. Annotations provide no safety hints (all false), leaving the description to carry the burden, and it does not.

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

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

The description is concise and well-structured: a one-sentence summary followed by a bulleted list of operations. Every line adds information, and the format is easy to scan.

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

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

The description provides a solid high-level overview but misses critical operational context: it does not indicate which parameters apply to each operation (e.g., which parameters are used for create_metal vs create_fabric). An output schema exists to cover return values, but the description still leaves uncertainty about parameter usage per operation.

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

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

The input schema already covers parameter descriptions at 100%, so baseline is 3. The description adds value by explaining the operation parameter's enum values in plain language and grouping them by material type, which helps agents select the right operation. It does not map all parameters to operations, but the schema descriptions handle this.

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

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

The description clearly states the tool's purpose as 'Create and manage PBR materials in Blender' and enumerates specific operation types (create_fabric, create_metal, etc.), making the scope explicit. It distinguishes itself from sibling tools like blender_textures or blender_shaders by focusing on PBR material creation and assignment.

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

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

The description provides clear context: it is for creating and managing PBR materials, with a list of sub-operations. However, it does not explicitly state when to use this tool over alternatives (e.g., blender_shaders or blender_textures) or provide exclusion criteria, so it falls short of a 5.

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

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

Annotations are all false, leaving the description to carry the burden. The description only states the conversion outcome but doesn't disclose side effects such as file writes, material modifications, or whether original materials are backed up. The mention of 'Prevents Semantic Dilution' is a value proposition, not a behavioral disclosure.

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

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

Two concise sentences: the first gives the core function, the second gives the use case. No redundant words, and the marketing-like 'Semantic Dilution' phrase adds a memorable rationale.

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 (10 params, multiple operations), the description is somewhat thin. It focuses on one operation (convert shaders) but doesn't mention other operations like consolidate_materials or optimize_for_mobile. Output schema covers return values, but the description doesn't address when to use different operations or what side effects occur, leaving 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?

All 10 parameters have schema descriptions (100% coverage), so the baseline is 3. The description doesn't elaborate on parameter meanings beyond the schema, but the high-level purpose helps interpret parameters like 'operation' and 'bake_type' in the context of converting VRM/MToon to PBR.

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

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

The description opens with 'Convert non-standard (VRM/MToon) shaders to PBR textures,' which clearly states the tool's action and target. It distinguishes from sibling tools like blender_shaders or blender_materials by focusing on conversion to PBR, and the Resonite/Unity context adds specificity.

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

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

The phrase 'Essential for VRM avatars moving into Resonite, Unity, or other PBR-based environments' provides a clear when-to-use context. However, it doesn't name alternatives or specify when not to use, so it's not a 5.

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

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

The description explicitly lists destructive operations such as 'delete_object: Remove objects from scene by name' and 'delete_faces: Delete selected faces', yet the annotations declare destructiveHint=false. This is a direct contradiction. Additionally, the description omits behavioral details like requirements for edit mode or permanence of deletions.

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

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

The description opens with a meta 'PORTMANTEAU PATTERN RATIONALE' that is not operationally useful and bloats the entry. The core description is then buried behind this rationale. While the operation list is structured with bullets, the overall length and unnecessary rationale make it less concise and front-loaded.

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

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

With 18 parameters and many operations, the description lacks essential context such as prerequisites (e.g., needing an object in edit mode for extrude/inset), selection requirements, coordinate systems, and the mapping of parameters to operations beyond create/duplicate/delete. The output schema exists, so return values need not be explained, but the operational context is still insufficient.

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 parameter description coverage is only 50%. The description adds some value by specifying parameter requirements for create/duplicate/delete operations (e.g., 'create_* require: name'), but it fails to explain many parameters such as distance, thickness, join_names, bevel_width, inset_depth, bevel_segments, merge_distance, prefer_session, and subdivide_cuts, which remain undocumented in both schema and description.

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 creates and manipulates mesh objects in Blender with primitive support, and enumerates specific operations. However, it confusingly claims to consolidate '9 related mesh operations' while listing 18, and does not explicitly distinguish itself from sibling tools like blender_scene or blender_transform.

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 direct guidance is given on when to use this tool versus alternatives. The portmanteau rationale mentions preventing tool explosion, but it does not specify scenarios or exclusions. For a tool with many overlapping siblings, this is a significant gap.

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

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

Annotations provide no safety hints (readOnlyHint, destructiveHint are all false), so the description carries the transparency burden. It lists operations like apply_modifier and remove_modifier without warning about their potentially destructive/irreversible nature. It does reveal basic behavior through operation names, but lacks details on side effects, permissions, or workflow consequences.

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. It opens with a clear one-sentence summary, then lists operations in a scannable bullet format. No redundant or filler content; every line adds informational value.

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

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

The description covers all intended operations and parameter categories sufficiently for a tool of this complexity. It could be more explicit about which parameters are required for each operation and whether object_name is mandatory. An output schema exists, so return value details are not necessary. The main gap is missing prerequisites or interaction notes, showing slight incompleteness.

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 already provides descriptions for all 12 parameters (100% coverage). The description adds value by enumerating the valid values for the 'operation' parameter and implicitly linking parameters to operations (e.g., add_array uses count, add_subsurf uses levels). This goes beyond the schema's generic 'Modifier operation type' description.

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 'Apply and manage mesh modifiers in Blender' with a specific verb and resource. It distinguishes itself from sibling tools like blender_mesh and construct_object by focusing exclusively on modifiers. The list of supported operations further clarifies the tool's scope.

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 described operations imply when the tool should be used (e.g., add_subsurf for subdivision, remove_modifier for removal), but there is no explicit guidance on when to prefer this tool over alternatives. No exclusions or alternative tool references are provided, making the usage context implicit rather than explicit.

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

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

Annotations are all false (readOnlyHint=false, etc.), leaving the description to carry the burden. The description lists multiple mutating operations (create, bake, control, set) which implies scene modification, but it does not disclose side effects like overwriting existing particles, performance costs of baking, or prerequisites. It adds some context beyond annotations but not rich behavioral detail.

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

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

The description is efficiently structured with a one-sentence summary followed by a bulleted list of operations. It is slightly long due to the list, but each line earns its place and information is easy to scan. Front-loading the core purpose works well.

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 multi-operation complexity and the presence of an output schema, the description effectively outlines what operations are available. It does not explain when to choose each operation, but the operation names are self-descriptive. It lacks a note on prerequisites (e.g., object existence), but the parameter schema and output schema fill in most 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 coverage is 100%, so parameters are already well-documented. The description adds value by listing the valid values for the 'operation' parameter, which the schema does not provide as an enum. This helps the agent understand the operation sub-types beyond the schema's generic 'Particle operation type'.

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

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

The description clearly states 'Create and manage particle systems and effects' and enumerates specific operations (create, control, bake, set physics), using a specific verb plus resource. It distinguishes itself from sibling tools by focusing exclusively on particle-related functionality.

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 through its title and operation list, but it does not explicitly state when to use this tool versus closely related siblings like blender_physics or blender_animation. No alternatives or exclusions are mentioned, so guidance is only implied.

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

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

Annotations provide no positive hints (readOnlyHint false, destructiveHint false, etc.), leaving the description to carry the burden of behavioral disclosure. The description lists operations like 'bake_physics' and 'add_force_field' but does not explain side effects, such as overwriting existing physics settings, modifying keyframes, or potentially non-reversible actions. For a mutation tool, this is a significant gap.

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

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

The description is a concise, structured bullet list. The opening sentence states the purpose, followed by a clear enumeration of operations. No wasted words; every line earns its place. It is front-loaded and easily scannable.

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 (10 parameters, 7 distinct operations) and no positive annotations, the description is minimally adequate but incomplete. It does not explain which parameters apply to which operations, whether operations are mutually exclusive, or any dependencies (e.g., object must exist). An output schema exists but is not shown; the description could still benefit from usage scenarios or operation-specific parameter notes.

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

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

Schema coverage is 100% for all 10 parameters, so the baseline is 3. The description goes beyond schema by listing valid values for the 'operation' parameter (enable_rigid_body, enable_cloth, etc.) and implicitly maps operations to physics types. This adds meaningful context that the schema's generic 'Physics operation type' lacks, enhancing parameter understanding.

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

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

The description states a clear purpose: 'Enable and configure physics simulations for objects.' It then enumerates specific operations, distinguishing it from sibling tools like blender_particles or blender_modifiers. The verb 'enable/configure' plus resource 'physics simulations' is specific and unambiguous.

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

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

The description implies usage for physics-related tasks but does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or prerequisites. It lists operations but without context like 'use enable_rigid_body for rigid body dynamics' or 'bake for animation export.' This is implied guidance 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?

Annotations already indicate readOnlyHint=false, so the agent knows mutations are possible. The description adds a little context, such as 'screenshot_viewport: ... prefers live GUI session', but does not disclose side effects like changing Blender settings or writing files beyond the operation names. It does not contradict the annotations.

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

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

The description is well-structured with a bullet list and example, making it easy to scan. The inclusion of 'PORTMANTEAU PATTERN RATIONALE' is unnecessary meta-commentary, but the rest is informative and front-loaded with the core purpose.

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

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

Given 23 parameters with no schema descriptions, the description is not fully complete. It lists operations but does not map which parameters are relevant for each operation, nor does it clarify the distinction between output_path and output_dir. The presence of an output schema helps with return values, but the parameter mapping gap remains.

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 coverage, the description must compensate. It partially does by explaining operations that map to parameters (e.g., 'set_engine' covers render_engine/samples/device, 'setup_post_processing' covers bloom/SSAO/motion blur/DOF). However, many parameters like output_dir, frame_start, resolution, and elevation_deg are left undefined, so the compensation is incomplete.

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 it 'consolidates rendering operations into a single interface' and lists concrete sub-operations like render_preview, render_turntable, and render_animation. This makes it unmistakably the rendering-focused tool, distinguishing it from siblings like blender_animation or blender_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 via the operation list (e.g., use 'render_preview' for a single frame), and the example shows a typical call. However, it never explicitly says when to prefer this tool over alternatives or when not to use it, leaving the agent to infer the context.

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

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

Annotations are all false, so the description carries the burden. It discloses the portmanteau design and lists operation names, but does not mention that operations are selected via the 'operation' parameter, nor describe side effects like scene modification or irreversibility (e.g., manage_vertex_groups can remove groups, reset_pose clears transformations). The description focuses on what operations exist, not how the tool behaves.

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

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

The description is well-structured with clear categories, but the opening 'PORTMANTEAU PATTERN RATIONALE' paragraph is largely meta-commentary that does not aid invocation. The bullet lists are useful but partially duplicate the schema's operation enum. It earns a middle score due to organization but is padded with non-essential rationale.

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 (25 parameters, 11 operations), the description provides a high-level overview and grouping but fails to explain that exactly one operation is executed per call based on the 'operation' parameter, or that parameters are conditional per operation. The output schema exists but is not shown, so the description carries some burden. It is adequate but leaves practical usage flow implicit.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's categorization of operations helps associate parameters with operations, but it does not add parameter-specific meaning beyond the schema. The parameter descriptions in the schema already cover usage details, so the description neither compensates nor detracts significantly.

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

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

The description clearly identifies the tool as a 'Complete character rigging system for Blender' and enumerates all 11 operations across five categories. This gives a specific verb (rigging), resource (Blender armatures/bones), and distinguishes it from any sibling tool since no other rigging-specific tool is listed.

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 character rigging is needed and lists operations grouped by workflow stage, but it does not provide explicit when-to-use vs alternatives or exclusions. It lacks statements like 'For animation keyframing, use blender_animation instead.' The rationale about preventing tool explosion gives context but no actionable 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 annotation states destructiveHint=false, but the description explicitly lists 'clear_scene: Clear all objects from current scene', which is a destructive operation. This is a direct contradiction between the description and the annotations. Additionally, the description does not disclose other behavioral traits such as parameter requirements per operation or side effects beyond the operation list.

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

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

The description is efficiently structured with a one-sentence summary followed by a bulleted list of operations. Each line is concise and adds direct information. There is no unnecessary verbosity, and the front-loaded summary provides immediate orientation.

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?

Despite having an output schema and comprehensive parameter descriptions, the tool description does not explain which parameters apply to which operations. For example, setup_camera likely requires 'location' and 'rotation', but this mapping is absent. The description also omits information about default behaviors, prerequisites, or how the output varies by operation, making it incomplete for a tool with this complexity.

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

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

The input schema already has 100% description coverage for all 10 parameters, with clear descriptions like 'Position as [x, y, z] for camera/light'. The tool description adds no additional parameter semantics beyond listing the operations, which map to the 'operation' enum already present in the schema. Baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly identifies the tool as a comprehensive scene manager for Blender and enumerates 12 specific operations with brief explanations, such as 'clear_scene: Clear all objects from current scene'. This makes the tool's purpose unmistakable and distinguishes it from sibling tools that focus on singular 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?

The description does not provide any guidance on when to use this tool versus the many sibling tools that appear to cover the same operations (e.g., create_scene, list_scenes, set_active_scene, create_collection). No exclusions or alternative recommendations are given, leaving the agent to infer when the dispatcher-style tool is preferred over individual tools.

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

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

Annotations are all false, providing little safety information, so the description carries the burden of disclosing behavior. It adds useful context like 'dynotopo: enable/disable dynamic topology' and 'exit: leave sculpt mode (default back to OBJECT)', which hint at state changes. However, it does not disclose potential side effects of operations like 'mask_clear' or 'remesh_voxel', nor does it mention prerequisites (e.g., an active mesh object) or error conditions beyond a generic return 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 well-organized with a short intro, a bulleted operation list, a return format section, and a code example. Every element serves a purpose: the bullets cover all operations, the return format sets expectations, and the example clarifies invocation. It is concise without unnecessary fluff.

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

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

Given the tool's complexity (12 parameters, multi-operation dispatcher), the description is not fully complete. It provides a comprehensive operation list and an example, and the output schema covers return values. However, it omits critical details such as required parameters per operation, parameter ranges, and the meaning of ambiguous fields like prefer_session and adaptivity. This leaves the agent with reasonable but incomplete guidance.

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

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

With 0% schema_description_coverage and 12 parameters, the description must compensate. It partially does by mapping operations to parameters (e.g., 'set_brush: assign brush with strength and radius' corresponds to strength and radius; 'remesh_voxel' implies voxel_size). The example shows usage of operation and object_name. However, many parameters like adaptivity, prefer_session, target_mode, and detail_resolution are not explained, leaving ambiguity for the agent.

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 'Sculpt mode operations for organic mesh editing' and enumerates a specific list of operations (enter, exit, set_brush, dynotopo, symmetrize, mask_clear, remesh_voxel, list_brushes) with short verb+resource explanations. It distinguishes itself from sibling tools by focusing exclusively on sculpt mode, which is a unique domain in the toolset.

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 establishes clear usage context by stating the tool is for 'Sculpt mode operations' and providing operation-specific details such as 'enter: switch object to sculpt mode' and 'exit: leave sculpt mode (default back to OBJECT)'. It implicitly tells the agent when to use this tool (when sculpt-related actions are needed) versus alternatives, but it does not explicitly name alternative tools or state 'when not to use' conditions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is covered. The description adds the list of supported operations, which is useful context, but it does not describe selection mode interactions or any other behavioral details beyond what the operation names imply.

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, uses a clear bulleted list, and every sentence serves a purpose. It efficiently communicates the tool's capabilities without redundancy or fluff.

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

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

The tool is low-complexity, the schema covers all parameters, and annotations cover safety. The description lists all supported operations, making it complete for understanding the tool's main behavior. Minor gap: no mention of selection mode (REPLACE/ADD/SUBTRACT) semantics, but that is a parameter detail covered by the schema.

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

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

Schema description coverage is 100%, so each parameter is already documented. The description adds a semantic grouping of operations to parameters, but it doesn't provide additional meaning beyond the schema descriptions. Baseline 3 is appropriate when schema fully covers 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: 'Select objects and elements in Blender scenes.' It lists specific operations (select_objects, select_by_type, etc.) that make its scope and function unambiguous, distinguishing it from generic Blender 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 implies usage by listing the available operations, but it does not explicitly explain when to use this tool versus alternatives, nor does it provide exclusions or when-not-to-use guidance. The context is clear for simple selection tasks, but it lacks explicit guidance relative to sibling tools.

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

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

The description reveals key behavioral details beyond the annotations (all false), such as 'stop: kill the managed Blender GUI process' and the bridge addon requirement for run_script. This provides helpful context about side effects and prerequisites. No contradictions with annotations were found.

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 well-organized bulleted list with clear sub-points. Each line serves a purpose: defining the tool's scope, listing operations, and noting prerequisites. There is no redundancy or filler, making it efficient and easy to scan.

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

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

Given the tool's multi-operation complexity, the description covers all operations, their parameters, and the bridge addon prerequisite. An output schema exists, so return value details are not needed. Minor gaps such as error handling or behavior when Blender is not running are not addressed, but overall completeness is adequate.

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

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

The input schema already provides operation-specific descriptions for every parameter (100% coverage). The description adds value by listing the available demo names for demo_name and grouping parameters by operation, which helps disambiguate. However, it does not drastically enrich parameter meaning beyond the schema's existing 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 begins with 'Manage a Blender GUI session from the MCP server', which is a specific verb+resource statement. It then lists five distinct operations (status, start, stop, run_script, demo), making the tool's scope unambiguous. Although it doesn't explicitly differentiate from siblings, the operation list clearly distinguishes it from single-purpose tools like blender_render or script_execute.

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

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

The description implies when to use the tool by enumerating operations, but it does not explicitly state when to prefer this tool over alternatives such as script_execute or blender_status. It does provide a useful prerequisite for run_script (bridge addon enabled), but lacks exclusionary guidance or reference to sibling tools.

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