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

With no annotations provided, the description must disclose behavioral traits, but it only states the action without mentioning side effects, error behavior, or whether modifiers are additive or replaced. It does not clarify if the tool fails silently or requires existing objects.

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

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

The description is a single, efficient sentence that puts the primary action first and lists supported modifier types concisely. There is no verbosity or redundant information.

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

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

For a mutation tool with no annotations and no output schema, the description is sparse. It does not explain return values, what happens if the object does not exist, whether the operation is reversible, or how configuration parameters interact with specific modifier types. This leaves significant gaps for an agent to use it correctly.

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

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

The input schema has 100% description coverage for all properties, so the baseline is 3. The description adds no new meaning beyond the schema; it repeats the modifier types (already in the enum) and hints at configuration via examples, but the schema already includes those examples. No extra parameter insight is provided.

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

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

The description clearly states the action ('attaches and configures'), the resource ('procedural modifier'), and the target ('mesh object'), while enumerating the supported modifier types. This differentiates it from sibling tools that handle cameras, primitives, or materials.

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

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

No guidance is provided on when to use this tool versus alternatives like blender_execute_bpy, which could also apply modifiers via scripting. The description offers no context for selection or exclusion 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?

With no annotations, the description carries the full burden. It discloses that the operation is 'instantaneous' (non-render) and returns a Base64 PNG. It does not mention potential side effects, but capturing a screenshot is inherently read-only and unlikely to modify the scene. The description adequately conveys its non-destructive nature and output 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 a single, efficient sentence that places the primary action first and includes the key output detail. There is no filler or repetition, making it concise and easy to parse.

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

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

Given zero parameters, no output schema, and a simple side-effect-free action, the description covers everything an agent needs to know: what it captures, how it returns the result, and the purpose. No missing information affects correct 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?

The input schema has zero parameters, so no parameter documentation is required. Per the rubric, a baseline of 4 applies for 0 parameters. The description adds no parameter-specific info, but none is needed.

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 verb 'captures' and the resource '3D viewport', and specifies the output format (Base64 PNG). This distinguishes it from sibling tools like blender_inspect_scene, which deals with scene data rather than visual captures, and from setup tools that modify state.

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?

It states the tool is for 'multimodal visual inspection', giving context for when to use it. However, it does not explicitly mention alternatives or when NOT to use it. Given the sibling list includes blender_inspect_scene, a brief exclusion would improve guidance, but the intended use is clear enough.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'creates' an object, implying an additive operation, but does not disclose side effects such as whether the object is added to the active scene, whether naming collisions are prevented beyond the 'unique name' schema hint, or whether an undo step is created.

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, tightly written sentence that front-loads the core action and immediately enumerates the supported primitive types. Every part is useful and there is no wasted wording.

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 creation tool with a fully described input schema, the description is minimally adequate. However, with no output schema and no annotations, it leaves out some operational context such as what the tool returns (e.g., created object name), coordinate-space assumptions, and any scene-state 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 100%, so the parameters are already well documented. The description adds only a high-level context ('3D procedural primitive') and repeats the primitive type list already present in the enum; it provides no additional meaning for size, scale, location, or rotation beyond what the schema states.

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 ('Creates') and a precise resource ('3D procedural primitive'), and enumerates the supported types (cube, sphere, cylinder, torus, plane, cone, monkey). This clearly distinguishes the tool from siblings like camera setup, modifiers, materials, and scene export.

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 explains what the tool does but gives no explicit guidance on when to prefer it over alternatives. It does not mention, for example, that it should be used instead of blender_execute_bpy for primitive creation or that other tools should be used for sculpting/modeling operations.

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 two important behavioral traits: 'full error containment' and 'return value capture.' This goes beyond a generic 'runs scripts' statement. However, it does not describe side effects on the Blender scene, whether changes persist, or how errors are surfaced (e.g., exception messages vs. structured errors), which could be vital for a general execution tool.

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

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

The description is a single, well-structured sentence. It front-loads the primary action ('Directly runs'), then adds the key features ('full error containment and return value capture'). There is 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?

While the description captures the core function and main behaviors, it leaves gaps: it doesn't describe the output format (e.g., what exactly is returned), how errors are reported (e.g., thrown exceptions vs. status codes), or potential side effects on scene state. Given that this tool executes arbitrary code, these omissions could lead to agent confusion. However, since there are no annotations or output schema, the description is the only source of information, so more completeness would be beneficial.

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

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

The input schema already describes the single parameter 'code' as 'Python script utilizing the bpy API.' The description adds the adjective 'custom' but no further semantics. With 100% schema coverage, the description adds minimal value beyond what the schema already conveys.

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 executes Blender Python scripts, which is a specific verb and resource. It distinguishes itself from sibling tools (which are specialized actions like creating primitives or capturing viewport) by being the general 'run any bpy code' tool. It also mentions error containment and return capture, further clarifying its role.

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 tool for arbitrary custom scripts, but it does not explicitly state when to use it versus the specialized sibling tools. It lacks guidance on exclusions or when to prefer other tools, requiring the agent to infer the intended usage from the contrast with 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'bakes' but does not clarify whether baking modifies the in-memory scene, whether existing files at output_path are overwritten, or what the tool returns on success/failure. For a file-writing operation, these side effects are important and unaddressed.

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

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

The description is a single efficient sentence with no filler. The core action and formats are front-loaded, and everything present earns its place. It is concise without being under-specified for the purpose it states.

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 2-parameter export tool, the core purpose and input semantics are covered well. However, with no output schema and no annotations, the description leaves important contextual gaps around side effects, return values, and failure behavior, making it merely adequate rather than 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 description coverage is 100%, and both parameters already have meaningful descriptions in the schema. The tool description repeats the format options but adds no extra meaning for output_path, such as extension handling, directory requirements, or overwrite behavior. Baseline 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 specific action ('Bakes and exports'), the resource ('current 3D scene'), and the concrete output formats (.glb, .gltf, .obj, .stl, .fbx). This naturally distinguishes it from siblings like blender_capture_viewport or blender_inspect_scene, which serve 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 gives clear context: use this tool when the current 3D scene needs to be converted into a standard 3D model file. It does not explicitly state when not to use it or name alternatives, but the format list and 'current 3D scene' scope make the intended usage obvious.

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 burden of behavioral disclosure. It states what it reports (status, version, engine, readiness) but doesn't disclose potential side effects (e.g., network calls, system checks) or performance implications. It doesn't contradict annotations since none exist.

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?

A single, concise sentence that efficiently lists the key outputs. It is front-loaded and contains no fluff. Perfect for a zero-parameter read-only tool.

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

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

Given zero parameters and no output schema, the description provides sufficient information for an agent to understand the tool's purpose and what it returns. It lacks details on edge cases (e.g., error behavior if Blender is not running), but those are not essential for basic invocation. Complex enough to warrant a near-perfect score.

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

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

The tool has no parameters, and schema coverage is 100%, so there is nothing to clarify. A baseline of 4 is appropriate because no parameter info is needed.

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 reports the tool's purpose: checking connection status, Blender binary version, simulation engine, and system readiness. It uses a specific verb and lists the exact outputs. It is distinguishable from siblings, which are about setup, creation, modification, etc., though it doesn't explicitly differentiate.

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?

It implies a health-check use case: one would call this to verify environment readiness before other operations. However, it doesn't explicitly state when to use it versus alternatives (e.g., before setup or export) nor when not to use it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description states it 'retrieves' metadata, which implies a non-destructive read, but it does not explicitly say whether it mutates the scene, requires permissions, or has side effects. It also does not describe the output format or behavior on failure (e.g., empty scene). For a tool with zero annotations, 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 single sentence, concise and front-loaded with the main action. The list of data types is useful but could be seen as slightly dense; still, every word adds value and nothing is redundant. It could be restructured to separate the core purpose from the details, but it is not overlong.

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

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

Given the tool's complexity (a read-only inspector) and the fact that it has no parameters and no output schema, the description should explain what the tool returns and when to use it. The description covers the return content well but lacks guidance on preconditions, error scenarios, or alternative tools. It is adequate for a simple read, but an agent might not know if the scene can be empty or what happens then.

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

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

The tool has zero parameters, so the schema provides no parameter semantics. The description compensates by enumerating the specific data that will be returned (mesh objects, transforms, polygons, vertices, materials, modifiers), giving the agent a clear idea of what to expect. Although it doesn't cover everything an output schema might, for a no-parameter tool this is sufficient.

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 a clear verb ('Retrieves') and resource ('complete inspection metadata from the 3D scene'), and enumerates the specific content (mesh objects, transform coordinates, polygon counts, etc.). It is distinct from sibling tools, which focus on creating, modifying, exporting, or capturing, so an agent can infer it is a read-only inspection tool. However, it does not name a sibling explicitly as an alternative, which would have made its uniqueness even clearer.

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 read-only inspection snapshot, and given the sibling list (e.g., blender_execute_bpy, blender_capture_viewport), an agent can roughly guess when to use it. But there is no explicit guidance on when to use this tool versus alternatives, nor any mention of prerequisites (e.g., must have an open scene) or what happens if no scene is loaded. The context is clear enough for a basic read operation, but it lacks explicit routing.

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 behavioral burden. It does disclose the main behavior—creating a Principled BSDF material and binding it to an object—which is more informative than a bare 'creates material'. However, it does not mention important side effects such as whether existing materials are replaced, whether the object must already exist, or what happens if the material name already exists.

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 with no filler, front-loading the key action and material type before listing the supported features. Every phrase adds useful information, and the structure is efficient for an agent to parse quickly.

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

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

The full schema covers parameters well, so the agent can construct a valid call. However, the description lacks details about prerequisites (object must exist), the effect on existing material slots, and what the tool returns since there is no output schema. This leaves some gaps, but the core invocation path is understandable.

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 input schema already documents every parameter in detail (e.g., RGBA base_color, metallic factor, transmission weight). The description only summarizes 'metallic, roughness, glass transmission, or emission' at a high level, adding no new parameter-level meaning 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?

The description uses a specific verb ('Creates'), a clear resource ('physically-based (PBR Principled BSDF) material'), and an explicit binding action ('binds it to an object'). It also enumerates the supported material qualities, which distinguishes this tool from all sibling Blender tools, none of which handle materials.

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 implies when to use this tool: when an object needs a PBR/Principled BSDF material with metallic, roughness, glass transmission, or emission characteristics. It does not explicitly name alternatives or exclusions, but the context is unambiguous given the sibling list, so an agent can infer this is the material-creation 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 carries the full burden of behavioral disclosure. It does say the camera is created and positioned, which implies scene mutation, but it doesn't mention whether an existing camera is replaced, a new camera is added, or what defaults apply when location is missing. For a tool that changes scene state, this is only minimal 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 a single, front-loaded sentence with no filler, repetition, or off-topic information. It communicates the operation and the primary camera adjustments efficiently and each phrase contributes meaning.

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?

This is a simple 4-parameter tool with an input schema that already documents all parameters, and no output schema is required. The description gives the core purpose, but the lack of annotations and the absence of details about side effects, defaults, or scene expectations makes it merely adequate rather than fully context-rich for an autonomous agent.

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

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

The input schema covers 100% of the parameters, so the baseline is 3. The description adds conceptual value by mapping the schema parameters to camera behaviors via 'look-at target tracking' and 'focal length lens adjustments,' but it doesn't add concrete details beyond what the schema already provides.

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

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

The description uses a specific verb and resource: 'Creates and positions the scene camera' with look-at target tracking and focal length adjustments. This clearly conveys what the tool does and is sufficiently distinct from the sibling tools such as blender_setup_lighting, though it doesn't explicitly name alternative 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 doesn't state when to use this tool versus the alternatives, nor does it specify any workflow context, prerequisites, or exclusions. The intended use is inferable from the verb and camera naming, but there is no explicit guidance for an agent deciding between this and tools like blender_capture_viewport or blender_inspect_scene.

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. It explicitly states the mutation effect ('creates or configures') and that it operates 'in the scene', providing some transparency. However, it does not disclose side effects such as whether existing lights with the same name are overwritten, whether the operation is reversible, or any scene prerequisites. This is a moderate disclosure, lacking deeper 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 a single, efficient sentence that front-loads the verb and resource, then enumerates the key adjustable properties. Every word contributes to the meaning; there is no redundancy or fluff. It is concise and well-structured.

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 full schema coverage and no output schema, the description is adequate for an agent to understand the tool's function and parameters. It clearly states the purpose and the main fields (position, energy, color). The only missing piece is guidance on when to use it, which is a minor gap that does not prevent correct invocation once already selected.

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 schema already documents all six parameters. The description adds marginal value by clarifying 'energy wattage' as intensity and 'color tint' as RGB array, but these are already implied in the schema (e.g., 'Light intensity/wattage'). It does not introduce syntax or additional constraints beyond the schema, so the baseline of 3 applies.

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 'creates or configures' and the resource '3D light source', listing the specific types. This distinguishes it from sibling tools like blender_setup_camera (camera) and blender_create_primitive (geometry). An agent can immediately understand its scope without ambiguity.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention scenarios like setting up scene lighting, comparing with other lighting tools, or conditions when this tool is preferred. No exclusions or alternatives are mentioned, so an agent has to infer the appropriate context.

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