blender-mcp

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

No annotations are provided, so the description must convey behavioral traits. It discloses that the tool copies a file, mentions allowable paths (absolute or under output folder), and optional destination naming. However, it does not state whether existing files are overwritten, what happens on failure, or if the tool is destructive.

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

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

The description is extremely concise, with a clear one-line summary followed by three bullet-like parameter explanations. Every sentence serves a purpose with no wasted words.

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

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

Given the tool's complexity (3 params, no output schema), the description is adequately complete for a simple file copy operation. It explains the effect and parameter meanings, but lacks disclosure about overwrite behavior, error cases, or return value, which would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate fully. It explains source_path (existing image on disk, absolute or under output), name (optional destination filename), and group (optional subfolder). This adds meaningful context beyond the schema's bare titles and defaults.

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

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

The description states a specific verb 'copy' and resource 'image file into reference library under output/refs', clearly distinguishing its purpose. Among sibling tools like list_references or view_reference, it is uniquely about adding a file.

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 adding images to the reference library, but does not explicitly state when to use this vs alternatives like view_reference or list_references. No 'when not to use' guidance is given.

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

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

No annotations provided, so the description carries full burden. It mentions 'blend_file: Open this file first (forces headless)' and 'save_as: Save after applying', which gives some behavioral insight (side effects of file operations and forced headless). However, it doesn't disclose error behavior, return value, or that the tool modifies scene state (mutation). For a tool with no annotations, this leaves significant gaps.

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

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

The description is one compact paragraph plus a bulleted list for parameters. Every line adds value. The purpose is front-loaded. The only slight inefficiency is the list format being slightly verbose for param descriptions, but it's well-organized and skimmable.

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 6 parameters, 0% schema coverage, no output schema, and no annotations, the description covers parameter semantics well but lacks behavioral details (e.g., what happens if object_name is missing or preset is invalid, what the return value is). It doesn't mention whether it works with existing materials or replaces them. For a mutation tool with no annotations, it's adequate but 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 coverage is 0%, so the description must compensate entirely. It explains all 6 parameters with prose, including valid enum values ('metal, plastic, rubber, glass, wood') for preset, optional RGB/RGBA for color, and side-effect notes for blend_file and save_as. The target parameter is briefly described as '"auto", "live" or "headless"', echoing the schema but clarifying intent. It adds context beyond the schema's bare labels.

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

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

The description uses specific verbs and resources: 'Apply a procedural material preset (metal, plastic, rubber, glass, wood) to a mesh.' It clearly distinguishes from siblings like 'render', 'blender_status', or 'run_script' by focusing on material application. The listed presets also hint at how it differs from generic material 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 when to use (applying material preset to a mesh) but provides no explicit guidance on when not to use or alternatives. Siblings like 'run_script' or 'inspect_blend' are different domains, so some implicit differentiation exists, but a clear exclusion or context for choosing this over a more general material tool is missing.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It gives no indication of side effects, permissions needed, or whether the tool only reads state without modification. The tool is named 'blender_status' and described as a report, but the description does not explicitly confirm it is read-only or safe to call.

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

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

The description is a single short sentence that lists the key items reported. It is concise and front-loaded, but could be more precise (e.g., 'Lists the current Blender status' instead of 'Report').

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 no output schema, the description should clarify what the tool returns. It only mentions what aspects it reports (install, folder, state, templates, materials) but not the format or structure of the output. For a status tool with no parameters, this leaves significant ambiguity about what the agent will receive.

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 has 0 parameters and 100% coverage, so no additional description is needed for parameters. The description adds meaning by listing what the tool reports, which is helpful despite the lack of 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 states it reports Blender install, output folder, live-bridge state, templates, and materials. This is a specific verb ('Report') and resource ('Blender status'), but it does not clearly distinguish from sibling tools like inspect_blend or apply_material, making it merely adequate.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose blender_status over similar status-reporting or inspection tools, nor does it indicate any prerequisites or context for its use.

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 explains the core behavior (creates and saves a .blend file, optionally running a script, with compression). However, it does not disclose important side effects like potential file overwriting, error handling for invalid paths or templates, or authentication/authorization requirements. Since no annotations exist, the description carries the full burden, but it only partially fulfills it.

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

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

The description is extremely concise: one sentence for the purpose followed by a compact, well-structured Arg block. Every line adds value, no redundant text, and the key action is front-loaded. It is an optimal length for quick reading.

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?

Considering no output schema or annotations, the description covers the essential inputs and outputs. It explains parameters well but omits what the tool returns (e.g., success indicator or file path) and does not mention error conditions (e.g., overwrite behavior, invalid template). These gaps are minor for a creation tool but prevent full completeness.

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

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

The Arg section adds rich semantics to all four parameters: clarifies path is relative/absolute and appends '.blend', enumerates template values, explains script runs bpy code after template, and defines compress. Given 0% schema description coverage, the description fully compensates, making each parameter's meaning clear.

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 first sentence clearly states the action ('Create') and resource ('.blend file from a starter template and save it'). It distinguishes the tool from siblings like render, inspect_blend, and run_script by focusing on creation of a new file, which is unique among the listed sibling 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 does not provide any guidance on when to use this tool versus alternatives. It lacks explicit context such as 'use this to start a new project' or 'for modifying existing files, use add_reference or run_script'. The agent is left to infer usage solely from the name and brief purpose.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It indicates the tool inspects/describes, implying read-only behavior, but it does not explicitly state it is non-destructive, describe the output format, or mention any side effects or limitations such as output size or performance. This leaves the agent uncertain about the tool's full behavioral profile.

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

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

The description is appropriately sized: a one-sentence summary followed by bulleted parameter explanations. Every word earns its place, and the structure is clear and front-loaded with the primary 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 3-parameter tool with no annotations and no output schema, the description covers the core purpose and parameters well. However, it lacks context about what the 'describe' output looks like (though there is no output schema to rely on), and it does not explain the difference between 'live' and 'headless' targets or how this tool relates to siblings like 'blender_status' or 'open_in_live_session'. This leaves room for improvement.

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 has 0% description coverage, so the description must add meaning to the parameters. It does this effectively for all three: blend_file ('Inspect this file. Leave empty to inspect the live session instead.'), include_objects ('Include the per-object breakdown, not just the counts.'), and target ('Where to look when no file is given.'). However, target's enum values (auto/live/headless) are not further explained, which is a minor gap.

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

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

The description clearly states the tool's purpose with a specific verb ('Describe') and resource ('a scene'), enumerating the content areas (objects, transforms, materials, cameras, lights, render settings). This distinguishes it from siblings like 'blender_status' or 'render', which have different purposes.

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

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

The description implies usage context through the parameter explanations (e.g., 'Leave empty to inspect the live session instead') but does not explicitly contrast it with sibling tools or state when to prefer this over alternatives. There is clear context for the 'target' and 'blend_file' parameters, but no exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states that the tool lists files, but does not reveal whether listing is recursive, how paths are returned, whether it is read-only, or how the pattern parameter affects results. This is insufficient for safe agent invocation.

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

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

The description is a single concise sentence that is front-loaded with the verb and resource. However, it is too brief to cover necessary details; the conciseness is achieved at the expense of completeness. It earns its place for purpose but not for the omitted parameter context.

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

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

Given the tool's simplicity (one optional parameter, no output schema, no annotations), the description is incomplete. It fails to explain the pattern parameter, return format, or behavioral traits. The tool needs more context to be used correctly, especially compared to similar tools like 'list_references'.

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 one optional parameter ('pattern') with 0% schema description coverage, meaning the description does not mention or explain it at all. The description adds no value beyond the schema, failing to clarify what the pattern does (e.g., glob filtering) or its default behavior.

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

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

The description clearly states the verb 'list' and the resource 'files produced so far in the output folder.' It effectively distinguishes the tool from the sibling 'list_references' (which lists references, not output files), making the purpose 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?

No guidance is provided on when to use this tool vs. alternatives like 'list_references' or other listing tools. The description lacks any context about prerequisites, scenarios, or exclusions, leaving the agent without decision support.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool lists images; it does not mention side effects, return format, ordering, or whether it reads from the filesystem. For a read-only tool, this missing context is a notable gap.

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

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

The description is a single, front-loaded sentence with no fluff. Every word contributes to the meaning, making it both concise and structurally clear.

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 with one optional parameter and no output schema, so the description provides the core scope. However, it leaves out details like what the output list contains (paths or names) or any behavior around the group folder. For such a minimal tool, the description is adequate but not comprehensive.

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 has no descriptions (coverage 0%), but the description adds meaning by mentioning 'optionally one group folder', which maps to the 'group' parameter. This clarifies that the parameter is optional and represents a folder. However, it does not explain the expected format (e.g., relative path or folder name), so it is only minimally adequate.

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

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

The description uses the specific verb 'list' and clearly identifies the resource: reference guide images under output/refs, with an optional group folder. This distinguishes it from sibling tools like view_reference or add_reference, which have different actions.

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 as a listing tool for reference images, but it does not explicitly state when to use this tool versus the siblings (e.g., add_reference or view_reference). There is no mention of alternatives or exclusions, only the core action.

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

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

With no annotations provided, the description must carry the full burden. It discloses the core behavior (loading a .blend for viewing) and implies it is a non-destructive operation (loading for viewing). However, it does not specify what happens if the file doesn't exist, if the Blender session is not open, or if the file is already loaded. It also doesn't mention potential side effects (e.g., replacing the current scene). A 3 is fair because it covers basic behavior but misses deeper details.

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

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

The description is a single sentence of 16 words, which is concise and front-loaded with the key action ('Load a .blend'). It earns its sentence by conveying purpose and context (user's open window). No redundancy exists, but it could arguably add a bit more context (e.g., prerequisites) without significant bloat.

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

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

Given that the tool has 1 required parameter and no output schema, and the context signals indicate a simple tool, the description is somewhat incomplete. It does not specify what happens upon success (e.g., visual confirmation), how errors are handled, or whether the tool requires an active Blender session (sibling 'blender_status' suggests this is relevant). The return value is not critical since no output schema exists, but the lack of error/state context is a gap.

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%, meaning the schema provides no descriptions for the parameter, so the tool description must compensate. The description implies that 'blend_file' is the file to load, but it adds no additional details beyond the schema (e.g., file path format, supported file extensions, or whether it must be a local or relative path). Baseline is 3 given 1 parameter and 0% coverage, and the description does not elevate beyond that.

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

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

The description clearly states the verb 'load' and the resource '.blend file', and specifies its purpose for the user to see it in an open Blender window. This distinguishes it from sibling tools like create_blend (creation) or inspect_blend (analysis), though it doesn't explicitly name 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 implies the tool is used when a user has a Blender window open and wants to see a .blend file, but it does not provide explicit guidance on when to use it vs. alternatives, nor does it mention prerequisites (e.g., ensuring Blender is running). No exclusions or when-not-to-use statements are given.

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

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

With no annotations, the description must fully disclose behavior. It mentions low sample count and EEVEE engine preference but does not address critical traits like file modification, output handling, error behavior, or whether it opens a viewer. This leaves significant gaps for safe usage.

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

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

The description is short and to the point, with a clear two-sentence summary followed by a parameter list. It avoids fluff, though the parameter list could be more structured (e.g., types or defaults) without losing conciseness.

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 absence of annotations, output schema, and usage guidelines, the description fails to provide enough context for an AI to use this tool effectively. It does not explain the return value, interaction with sibling tools, or prerequisites, leaving the agent underinformed.

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

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

The description includes a parameter list with brief explanations for all 7 parameters, compensating for the 0% schema coverage. However, explanations are minimal (e.g., 'Preview width' adds little beyond the name), and details like valid engine values or the exact meaning of 'target' are omitted.

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 renders multi-angle EEVEE previews (front, three_quarter, side, top) for critique. This specifies both the verb (render) and the resource (specific angles), distinguishing it from sibling tools like render or viewport_screenshot which may produce single or different output.

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 others like render, render_and_view, or view_preview. It lacks explicit when-to-use, when-not-to-use, or alternative recommendations, leaving the agent to infer from context alone.

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

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

No annotations exist, so the description must fully disclose behavior. It mentions writing to disk and headless runs for blend_file, but lacks details on file overwriting, state changes to the live session, error handling, or blocking behavior. It is adequate but not comprehensive.

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

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

One-sentence intro followed by a clean bullet-style list of parameters. Efficient for 9 parameters, though the intro could be slightly tighter. No wasted words.

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

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

Covers parameter semantics thoroughly but omits behavioral context: no return value description, no mention of prerequisites (e.g., open scene), and no error handling guidance. With no output schema, the description should provide more operational context for safe 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 has 0% description coverage, so every parameter meaning must come from the description. The description adds rich value: explains relative vs absolute paths, engine semantics, frame default, transparent meaning, and target options. This is highly effective compensation.

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 'Render a still image and write it to disk', a specific verb+resource. It immediately distinguishes from the sibling 'render_and_view' with the recommendation 'Prefer render_and_view so you see it.' No ambiguity.

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

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

Explicitly directs to prefer an alternative sibling (render_and_view) and provides practical guidance on engine choice ('EEVEE for iteration; CYCLES for finals') and sample counts ('Keep it low for previews'). This helps the agent decide when and how to use the tool.

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

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

No annotations are provided, so the description must fully disclose behavior. It states the tool renders and returns an image, but it does not clarify whether it writes a file, what the return format is, or any side effects. The note 'PNG destination under the output folder' hints at file creation but lacks detail on permissions or destructive potential.

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: a one-line purpose followed by a cleanly structured Args list. Every line adds information. The phrase 'so you must look at it' is slightly informal but not wasteful. A bit more front-loading on the actual return behavior could improve it.

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 7 parameters and no output schema or annotations, the description should cover the return format, typical use, and constraints. It covers parameter meanings but misses details on what 'return the image' means (file path vs. data), the rendering process time, and how the output is delivered. The complexity of rendering requires more context.

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

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

With 0% schema description coverage, the description carries full burden for parameter meaning. It provides brief explanations for all 7 parameters (e.g., 'Sample count', 'Width in pixels'), adding value beyond the schema's name and defaults. However, some explanations are minimal (e.g., target options are listed without definitions) and do not fully compensate for the lack of schema descriptions.

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

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

The description clearly states the tool renders a still image and returns it for viewing. The verb 'Render' and resource 'still' are specific. However, it does not differentiate from the sibling tool 'render', which may have a similar purpose, lacking explicit distinction.

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

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

The description provides a minor usage hint ('Prefer EEVEE while iterating') for the engine parameter, but no guidance on when to use this tool versus alternatives like 'render' or 'view_image'. No context is given for the target parameter options 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?

The description discloses moderate behavioral details: pre-bound variables (bpy, mathutils, etc.), data return via 'result' or 'emit()', and print capture. It also notes that 'blend_file' forces headless mode. However, it omits warnings about potential destructive side effects (since arbitrary code can modify the scene) and does not discuss error handling, which is important for a script execution tool with no annotations.

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

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

The description is concise: three sentences for purpose and behavior, then a compact parameter list. Every sentence serves a purpose—intent, execution context, return mechanism, parameter details. No wasted words.

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

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

Given that this is a powerful arbitrary-code execution tool with no output schema and 15 siblings, the description is missing key elements: error handling, execution timeout/limits, any prerequisites (e.g., Blender must be installed), and when NOT to use it (e.g., for simple tasks better handled by specialized tools). It covers the immediate workflow but lacks safety and boundary context.

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

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

The input schema has 0% description coverage (no per-parameter descriptions), but the tool description provides clear explanations for all four parameters: 'code' (the Python to execute), 'blend_file' (open first, forces headless), 'save_as' (save after run), and 'target' (auto/live/headless). This fully compensates for the schema's lack of documentation, adding essential semantic value.

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 starts with 'Run Python against Blender's bpy API', which uses a specific verb and resource combination. This clearly distinguishes it from sibling tools like 'apply_material', 'render', or 'blender_status', which are task-specific rather than general-purpose scripting.

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 provided. With 15 sibling tools performing specific tasks (e.g., 'apply_material', 'render'), the description should advise when to pick this dynamic script runner instead of a specialized tool, but it does not.

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

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

With no annotations provided, the description must fully disclose behavioral traits, including side effects (e.g., opening a viewer window), prerequisites (e.g., a rendered image must exist), or limitations (e.g., image format support). The description only mentions loading an image but omits these details, leaving the agent unaware of important 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 very short, with a clear main sentence and a structured Args section for the parameter. It is efficient and front-loaded, but could be slightly more informative without adding length (e.g., mentioning file type support). The conciseness is commendable, but it leans toward under-specification.

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

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

Given the tool's simplicity (1 param, no output schema), the description covers the basic action but omits context about what 'load a rendered image' entails (e.g., does it open a GUI window or return the image data?). Without annotations or output schema, the description should provide more behavioral completeness, which it fails to do.

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 should compensate by explaining the 'path' parameter. The description notes 'relative to the output folder unless absolute', which adds some meaning, but it does not clarify expected formats (e.g., file extension) or relationship to other tools' outputs. This is marginally helpful but insufficient for a single parameter with no schema documentation.

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

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

The description states 'Load a rendered image so it can actually be looked at', which gives a specific verb ('load') and resource ('rendered image'). However, it lacks differentiation from siblings like 'view_reference' or 'view_preview', which may serve similar purposes. The purpose is clear but not distinct.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'view_reference' or 'view_preview'. There are no exclusions or context for when this tool is appropriate, which is a significant gap given the presence of multiple similar tools in the sibling list.

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

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

No annotations present, so description carries full burden. It only states the action and requirement. It does not disclose whether the operation is destructive, overwrites existing files, what file format is used, or any side effects. Lacks transparency on behavior beyond the basic action.

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

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

Two sentences with no extraneous information. The first sentence immediately states the purpose, and the second provides a critical prerequisite. Every sentence is earned.

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

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

For a simple tool with one optional parameter and no output schema, the description is adequate but incomplete. It does not explain what the output file is (image), where it is saved, or what format. The prerequisite is mentioned. Could be more complete by clarifying the output and any side effects.

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 mention the 'output' parameter at all. The parameter is simple (string with default), but the description should explain that it controls the filename of the captured screenshot. This is a missed opportunity to add value 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 the verb 'capture' and the resource 'live Blender window's 3D viewport'. Distinguishes from sibling tools like render (which produces a rendered output) and view_image (which views an existing image). Purpose is 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?

Specifies the prerequisite (MCP Bridge addon running in an open Blender session), which is helpful context. However, it does not provide guidance on when to use this tool versus alternatives like render or view_image. No explicit exclusions or when-not-to-use 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 no annotations, the description carries the full burden of disclosing behavioral traits. It only says 'Look at one preview PNG' without explaining side effects, permissions, blocking behavior, or what the tool actually does (e.g., open viewer, return data). This is minimal transparency for a read-like operation.

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

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

The description is short and front-loaded with the action. The args block is separate but minimal. It could be marginally more structured (e.g., bullet points), but overall it is efficient and free of waste.

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?

Without an output schema, the description should explain what the tool returns or how it behaves (e.g., displays image, returns base64). It only describes the input, leaving a gap in completeness for a tool that has no other documentation.

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

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

The input schema has zero description coverage, but the description adds the crucial detail that the path is 'relative to output or absolute,' clarifying the required parameter format. This goes beyond the schema and is helpful for correct usage.

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 looks at a preview PNG from specific sources (preview_views or a render). This distinguishes it from siblings like view_image (general images) and view_reference (reference images), making the purpose 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?

No guidance is provided on when to use this tool versus alternatives (e.g., view_image, render_and_view). There are no explicit usage conditions, exclusions, or prerequisites, leaving the agent without context for tool selection.

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

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

No annotations are provided, so the description bears full responsibility. It only says 'look at' which suggests a read-only operation, but it does not state whether the image is displayed in a specific panel, whether the tool has side effects, or if it returns any data. This is insufficient for a tool with zero annotation coverage.

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

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

The description is extremely concise: a single sentence stating the purpose followed by a short Args block for the parameter. Every piece of text is functional and front-loaded. No redundant or filler content is present.

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 (one parameter, no output schema), and the description covers the basic purpose and parameter format. However, it lacks detail about the outcome of the action (e.g., does it display the image in the 3D viewport or a separate viewer?) and does not differentiate from the sibling view_image, leaving gaps for an AI agent deciding between similar tools.

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

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

The input schema has 0% description coverage, so the description must clarify the parameter. It does so by stating 'path: Path relative to output/refs, or absolute.' This adds meaningful context beyond the schema's bare type/label, specifying the allowed path formats and default base directory.

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 'Look at a reference/guide image so you can match it while modeling,' which specifies a concrete verb (view) and resource (reference image). However, it does not explicitly distinguish itself from sibling tools like view_image or view_preview, leaving some ambiguity about when to use each.

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 'so you can match it while modeling' implies a use case, but the description provides no explicit guidance on when not to use this tool, nor does it mention alternatives such as view_image or list_references for browsing. The usage context is only lightly hinted.

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