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

With no annotations, the description carries the full burden and does disclose real behavior: it is coarse (not exact), crops both inputs to bounding boxes so position/scale are ignored, and returns JSON plus a color-coded overlay. It does not state whether the scene/model must already be loaded or that the operation is read-only, leaving some behavioral gaps.

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

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

Front-loaded with the core purpose ('Coarse likeness check') and compactly packs the mechanics and return format. Slightly dense with parentheticals but no wasted sentences.

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 comparison tool with no output schema and no annotations, the description covers what is compared, what is ignored, and what is returned. It omits the meaning of the 'objects' parameter and any precondition about the active scene, so it is adequate but not 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 0%, so the description must compensate. It explains azimuth/elevation as the render viewpoint and describes ref_image as alpha or plain-background, but it never mentions the 'objects' parameter at all, leaving that parameter 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 states a specific verb and resource: a silhouette-IoU likeness comparison between an orthographic render of the model and a reference image. It is quite specific about the computation, though it doesn't explicitly contrast itself against nearby siblings like blender_validate_asset or blender_screenshot.

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 labels itself a 'coarse likeness check' but gives no explicit when-to-use, when-not-to-use, or alternative routing. An agent cannot tell from this text when to prefer this over blender_validate_asset or a plain render/screenshot.

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 behavioral burden. It does disclose the key scoping default (whole scene when objects is omitted), which is real behavioral context, but it omits file overwrite behavior, path resolution rules, and any Blender server/connection requirements for a write-to-disk 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?

Two short sentences, zero filler, and the scoping rule is front-loaded right after the core action. Every clause earns its place.

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

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

For a simple 2-parameter export with no output schema, the description resolves the main ambiguity (object filtering) but leaves the required `path` parameter and connection/prerequisite context unexplained. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the `objects` parameter's effect (export only the named objects vs the whole scene) but says nothing about `path` (format, relative vs absolute, overwrite semantics), leaving half the parameters undocumented.

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?

States a specific verb and target format ('Export to a .glb'), which is clear and actionable. It does not explicitly contrast with the sibling blender_import_glb, but the export direction is unambiguous from the name and description.

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 conditional 'With `objects`, only those; otherwise the whole scene' tells the agent how the scope parameter changes behavior, which is useful. However, it gives no guidance on when to choose this over alternatives or any prerequisites (e.g., Blender must be running, scene must be loaded).

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 behavioral burden. It usefully discloses the return payload (new objects, triangle count, dimensions in metres), but omits whether existing scene content is preserved or replaced, whether the path must exist, and any Blender-session prerequisite.

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 front-loaded sentences with zero filler; the action and its result are both packed in without repetition.

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?

Since no output schema exists, the description's return-value summary is genuinely load-bearing, but for a mutation tool with no annotations and an undocumented parameter it still omits prerequisites and side effects an agent would need before calling it.

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 single path parameter has 0% schema description coverage, and the description adds nothing about it — no format, whether it is absolute/relative, or accepted extensions per-parameter (the format list is global). This leaves the only documented input under-specified.

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?

States a specific verb (Import) and resource (GLB/glTF/FBX) plus the target scope (the open scene), which cleanly separates it from blender_export_glb. It stops short of explicitly naming sibling alternatives, so it is clear but not fully differentiated in-text.

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?

"Into the open scene" implies a prerequisite (a scene must already be open, e.g. via blender_start/blender_open) but never states when to prefer this tool over blender_open or blender_new_scene, and gives no exclusions or failure 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?

With no annotations provided, the description carries the full burden. It discloses that all bones plus the object transform are keyed, which is useful behavioral context, but says nothing about whether existing keyframes at that frame are overwritten, whether the armature must be selected/active, or what the call returns. Adequate but with a clear gap for a mutation 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?

Two tight sentences: the action and its scope come first, the workflow second. No filler, and both sentences earn their place by adding distinct 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 keyframe-writing tool with no annotations and no output schema, the description covers what is written and where it sits in the pipeline, which is the core need. It omits overwrite semantics, preconditions, and any confirmation of return value, leaving an agent to guess on details that matter for a repeated write loop.

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 for three bare parameters. It explicitly explains `frame` and ties object keying to the `with_object` behavior ('plus the object's location/rotation'), but the `armature` parameter and the boolean's on/off semantics are left implicit. Partial compensation only.

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?

States a specific verb (keyframe) plus resource (current pose of the armature at a given frame) and the scope of what gets keyed (all bones plus the object's location/rotation). This clearly separates it from siblings like blender_set_pose and blender_pose_aim, which pose rather than record.

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 second sentence gives an explicit workflow: blender_timeline -> blender_pose_aim -> blender_key_pose, repeated per frame, which tells the agent exactly where this tool fits. It stops short of stating exclusions (e.g., that this is the final step before moving to the next frame), so it is clear context rather than a full when/when-not guide.

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. It does disclose one important behavioral trait — orphan data is purged, making this destructive and non-reversible — which is genuinely useful. However it omits permission/state requirements, whether the Blender session must be running, and what happens to scene-level settings.

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 compact clauses with zero filler. The destructive action is front-loaded and the parameter note follows. Every word earns its place.

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

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

For a single-optional-parameter tool with no output schema this is close to sufficient, and the purge semantics plus the keep example are the key facts. It still leaves the agent guessing about prerequisites (running Blender instance) and post-conditions, which matters for a destructive sibling in a large toolset.

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% (the schema only supplies a title and default for 'keep'), so the description must compensate — and it does, explaining the parameter is a list of object types to preserve with a concrete example ['CAMERA','LIGHT']. This gives the agent enough to construct the argument correctly.

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?

States a specific verb+resource: 'Remove all objects' with a parenthetical on orphan data. An agent can distinguish it from blender_open/import/export siblings. It's slightly weakened by the name 'blender_new_scene', which suggests scene creation rather than object removal, but the body resolves the 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?

No when-to-use guidance, no prerequisites (e.g. Blender must be running), and no reference to alternative cleanup paths such as blender_open or blender_run_python. The agent must infer the use case entirely.

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 behavioral burden. It implies a read but never states that it is non-mutating, whether Blender must be running, or what happens when the object name does not exist; it also gives no hint about the shape or size of the returned data.

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 front-loaded sentence that lists the returned fields with no filler. It is efficient, though the telegraphic noun-phrase style leaves room for a clarifying clause about the required argument.

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 no output schema, the description does list the return categories, which is the right move for a read tool. However, it omits preconditions and argument format for a tool that lives in a session lifecycle alongside blender_status/blender_start, leaving the agent to guess at invocation context.

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

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

Schema description coverage is 0% for the single object_name parameter, so the description must compensate. 'For one object' signals that exactly one object is targeted, but it never clarifies whether the identifier is a name, path, or index, or whether the object must be selected/active.

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 names a specific resource ('one object') and enumerates the data returned (transform, dimensions, materials, mesh stats), which is more informative than a bare title. It is implicitly a read/getter, though no verb is used and it never contrasts itself with the sibling blender_scene_info, which covers the whole scene.

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

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

There is no when-to-use guidance, no statement of when to prefer this over blender_scene_info or blender_rig_info, and no mention of preconditions such as Blender being started. The agent must infer that 'one object' means it takes a single object name.

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 and does disclose the critical destructive side effect: it replaces the current scene and loses unsaved changes. However, it omits other behavioral details such as whether Blender must already be running, what happens on failure, or what the tool returns.

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 that delivers the purpose and the most important caveat without any 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?

For a simple one-parameter open operation, the description covers the essential purpose and destructive side effect, but it leaves the parameter semantics unaddressed and provides no usage context relative to sibling tools. With no annotations and no schema descriptions, more detail would be expected for 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?

Schema description coverage is 0% and the description never mentions the required 'path' parameter or its expected format. The description adds no meaning beyond the bare schema, leaving a clear gap for a non-obvious input.

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 and resource: 'Open a .blend'. This clearly distinguishes it from siblings like blender_new_scene or blender_import_glb, though it does not name any alternative explicitly.

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?

There is no explicit guidance on when to use this tool versus alternatives such as blender_new_scene or blender_import_glb. The parenthetical warns about the destructive effect, but that is behavioral context rather than usage direction.

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 and does disclose meaningful traits: the precise aim target (head-to-continuing-child head, not the tail), parent-first ordering, and the return value (residual angle per bone in degrees). It does not explain what reset does or what happens to bones not listed in aim, leaving some behavioral gaps.

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

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

A single dense paragraph that front-loads the core concept and the distinguishing alternative. It is information-rich with little waste, though the inline example makes it slightly hard to parse.

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

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

For a nested-object tool with no output schema and no annotations, it covers the key concept, ordering, and return value well. However, the 'reset' default behavior and 'armature' target are never addressed, so it is 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 0%, so the description must compensate. It explains the complex 'aim' parameter via an inline example and its world-direction semantics, but leaves 'reset' and 'armature' entirely undocumented in both schema and description, covering only one of three params.

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?

States a specific verb+resource ('Pose by direction') and clarifies the mechanism (aiming each bone's limb along a WORLD direction). It also distinguishes itself from the sibling blender_set_pose, so an agent can pick between them without opening schemas.

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 names the alternative ('Prefer this over blender_set_pose for authoring poses'), giving a clear condition for selection. It lacks any when-not guidance or prerequisites, so it stops short of a full 5.

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

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

No annotations are provided, so the description carries the full burden. It usefully characterizes the meaning of the metrics ('volume loss = candy-wrapper joints', zero skin weight) but never states that the operation is read-only/non-mutating or describes return format or side effects, leaving key behavioral traits implied.

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?

It is a single dense sentence that is front-loaded with the core concept ('Deformation metrics of the CURRENT pose vs rest') before listing specifics. Slightly packed but no wasted framing.

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 read-only metrics tool with two required parameters and no output schema, the description conveys the computed quantities reasonably well. However, it omits any documentation of the parameters and any explicit non-mutation statement, leaving gaps for the 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?

Schema description coverage is 0% and the description never mentions the two required parameters (armature, mesh). With two undocumented parameters, the description fails to compensate for the schema gap, leaving their meaning to be guessed.

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 resource and measurement domain ('Deformation metrics of the CURRENT pose vs rest') and enumerates the exact quantities computed (face-area ratio percentiles, stretched/squashed face fractions, volume ratio, zero-weight vertex count). It is clear what the tool does, though it does not explicitly contrast itself against siblings like blender_rig_info or blender_compare_ref.

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?

There is no explicit when-to-use guidance and no named alternatives. The 'CURRENT pose' phrasing hints that a pose must be set first (e.g., via blender_set_pose), but this is left to inference rather than 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?

With no annotations, the description carries the full burden, and it does disclose real behavioral context: coordinate conventions (az 0 = front/-Y), what ortho does, how focus frames a world-space region, and that it returns images. However it is silent on scene side effects, the timeout, ignore_gpu_guard, engine selection, and error behavior for 10-param 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?

Front-loaded with the core purpose, then dense per-parameter detail with no filler. The inline JSON examples are compact, though the mode cross-reference to blender_turntable defers information an agent may not be able to resolve.

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 10-parameter tool with no annotations and no output schema, the description covers roughly half the parameters and the important geometry conventions. It omits several behavioral params (engine, timeout, ignore_gpu_guard, light, size) and gives only 'Returns the images' as a return-value note, leaving the definition partially 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 0%, so the description must compensate. It adds genuine meaning for views (az/el format and orientation), objects, ortho, and focus with a concrete example, but leaves mode, size, light, engine, timeout, and ignore_gpu_guard entirely 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?

States a specific verb and resource: 'Render explicit camera views', which clearly distinguishes it from the sibling turntable tool by emphasizing explicit az/el camera control. It does not name blender_render_scene or explain the split, but the resource and mechanism are 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?

Usage is only implied: the tool is for when you want specific framed camera angles rather than an orbit. It references blender_turntable for 'Modes as in' but does not state when to choose this tool over blender_turntable or blender_render_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 usefully discloses that rendering uses the scene's own camera/lights, that it is one image per frame, and what mode/hide do. However it is silent on the 300s timeout, the engine choice, and the GPU-guard flag, all of which affect invocation 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?

Compact and front-loaded: the core behavior comes first, then mode semantics, then hide. Telegraphic style is efficient, though the mode line is dense enough to require a re-read.

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 9-parameter render tool with no annotations, no output schema, and 0% schema coverage, the description is substantially incomplete. It leaves six parameters unexplained and says only 'Returns the images' without any format or shape 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?

Schema description coverage is 0% across 9 parameters, so the description must compensate. It only explains mode, objects, and hide; width, height, engine, frames, timeout, and ignore_gpu_guard remain completely undefined 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?

States a specific verb (render) and resource (the scene through its own active camera and lights), and the 'OWN active camera ... (shot rendering)' phrasing implies contrast with a sibling that uses a supplied camera. It does not name blender_render explicitly, so differentiation is inferred rather than stated.

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 mode list gives implied usage context (mask for silhouettes, hide for clean background plates), but there is no explicit when-to-use guidance and no reference to the sibling blender_render or blender_screenshot to route the agent between them.

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 behavioral burden. It does not say whether rotation, location, and scale are all reset, whether existing keyframes or animation data are affected, whether the operation is reversible, or what the response confirms. For a mutation tool with zero annotation coverage 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?

A single front-loaded sentence with no wasted words; the mutation and its target are stated immediately. It is arguably under-specified rather than 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?

With no annotations, no output schema, and an undocumented parameter, the definition should do more work: what exactly gets reset, whether animation/keyframes are impacted, and what to expect on return. As written it is too thin for a mutation tool.

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

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

Schema description coverage is 0% for the single required 'armature' parameter, and the description only echoes the word 'armature' without specifying the accepted identifier form (name, index, selected object). It does not 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?

States a specific verb+resource: returning all pose bones of an armature to rest pose. The word 'all' and 'rest pose' clearly distinguish it from sibling mutators like blender_set_pose and blender_pose_aim. No explicit sibling naming, but the semantics are 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 never states when to use this tool versus blender_set_pose, blender_pose_aim, or blender_key_pose, nor any prerequisites (e.g. armature must be selected or in pose mode). Usage is only implied by the tool name.

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

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

No annotations are provided, so the description carries full behavioral burden. It hints that data is rest-pose only (useful for distinguishing from blender_set_pose/blender_reset_pose), but says nothing about read-only nature, error behavior for a missing armature, permissions, or whether it mutates scene state.

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, front-loaded sentence that names the primary content and a secondary output. Efficient, though it reads more as a fragment than a full usage-oriented definition.

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 1-parameter info tool with no annotations, no output schema, and 0% schema coverage, the description leaves key gaps: parameter format, error conditions, and relation to siblings. The rest-pose note is helpful but 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 coverage is 0%, and the sole parameter 'armature' has no description in schema or tool description. It's unclear whether it expects a name, ID, or path. The description provides no syntax help, so it fails 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 names a specific resource (armature bones with rest-pose detail) and mentions bound meshes. It is distinguishable from sibling information tools like blender_object_info or blender_scene_info, though it doesn't explicitly contrast with them.

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 vs alternatives such as blender_object_info or pose tools. Nothing about prerequisites (must Blender be running? armature already loaded?) or when-not-to-use is present.

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 and does reasonably well: it discloses that each pose is applied and rendered, that a JSON report plus one image per pose is returned, and critically that 'the rig is reset to rest afterwards' — a real side effect. It omits failure behavior and whether the reset happens even on error.

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?

Efficient: the operation and its return shape are front-loaded in one sentence, followed by the usage caveat and the poses format. No filler sentences, though the poses syntax and the calibration warning are somewhat run together rather than cleanly separated.

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?

No output schema exists, but the description compensates by naming the returns (JSON report plus one image per pose) and the post-run reset. The main remaining gap is the undocumented non-pose parameters (mode, size, timeout, ignore_gpu_guard) that affect rendering and execution.

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% across 7 parameters, so the description must compensate. It does well for the most complex parameter, defining the poses format ('{"name": {"bone": [x, y, z]}} in degrees') and the default table, but leaves mesh, armature, mode, size, timeout and ignore_gpu_guard entirely unexplained.

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 and resource ('Range-of-motion test: for each pose apply it, measure deformation and render'), making the composite operation clear. It implicitly separates itself from single-pose siblings like blender_set_pose and blender_pose_metrics by describing a batch apply/measure/render cycle, but never names an alternative explicitly.

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 gives one concrete usage caveat: the built-in Mixamo pose table has uncalibrated axes, so the caller should inspect the images and supply their own poses. However, it never says when to prefer this over blender_pose_metrics or blender_set_pose, nor what prerequisites (armature + mesh already loaded) are needed. Usage is implied rather than specified.

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 usefully discloses that the return channel is stdout and that code runs in the user's session with real side effects, plus a reproducibility caution. It does not explain the timeout parameter's behavior, error/exception reporting, or what happens on a hung session.

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?

Key operational fact (return is stdout, use print) is front-loaded in the first sentence, with secondary guidance after. Two brief paragraphs with minor redundancy between 'Run Python inside Blender' and 'Executes arbitrary code in the user's Blender session.'

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 an arbitrary-code-execution tool with no annotations, no output schema, and 0% schema coverage, the return mechanism being documented is genuinely valuable. However, the timeout parameter and failure/exception behavior are left entirely unexplained, leaving gaps an agent must discover empirically.

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 compensates only partially: it clarifies the code parameter's expected behavior (output must be printed to stdout). The timeout parameter (default 60) is never explained — no units, no semantics for zero/exceeded values, no guidance on when to raise it.

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?

States a specific verb (run) and resource (Python inside Blender) and clarifies that bpy is available, so an agent knows this executes arbitrary script against the live Blender API. It does not explicitly contrast itself with the many specific siblings (blender_import_glb, blender_render, etc.), though its role as the general escape hatch is evident.

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?

There is no explicit when-to-use-this-vs-a-specific-sibling guidance, which matters because there are 24 specialized sibling tools. The only guidance given is about reproducibility (record changes in build scripts), which is a best-practice note rather than a tool-selection rule.

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 behavioral burden. It does not state that saving overwrites the existing file, whether the path's directory must already exist, what file format is written, or whether a running session is required — all important for a write 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?

A single front-loaded sentence with zero filler that covers both call modes. Every clause earns its place.

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

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

For a one-parameter tool with no output schema the description is close to adequate, but as an unannotated mutation it omits overwrite risk, session prerequisites, and file-format behavior that an agent needs before invoking it.

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, and it does: it defines `path` as triggering save-as behavior when supplied and implies an in-place save otherwise. It lacks detail on path format or directory requirements, but the parameter's role is genuinely clarified.

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 names a specific verb and resource (save the current file) and distinguishes itself from siblings like blender_open and blender_export_glb by scoping to the active file. It is clear but never explicitly differentiates itself from the other file-handling 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?

It explains the two modes of the tool (plain save vs save-as with a path) but gives no guidance on when to choose save over blender_export_glb or blender_run_python, nor any prerequisites such as requiring an active Blender session. Usage is only weakly 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?

With no annotations the description carries the full burden, and it does disclose the read-only nature and the shape of the return (objects, counts, active camera). It omits any note on permissions, cost, or freshness of the scene state, so it is adequate but not rich.

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

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

A single front-loaded sentence with no filler. Efficient, though the parenthetical could be tightened.

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?

No output schema exists, so the description must carry return-value expectations; listing objects/counts/active camera is a useful start but not exhaustive, and no behavioral context for the read is given. Minimum viable for a zero-param info 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 tool takes zero parameters, so the baseline of 4 applies; there is no parameter surface for the description to clarify.

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?

States a specific resource and scope ('summary of the open Blender scene') and enumerates the contents (objects, counts, active camera), which naturally distinguishes it from the object-level sibling blender_object_info. It lacks an explicit verb and no sibling is named, keeping it below a 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?

No when-to-use guidance, no prerequisites, and no alternatives named among the many siblings. An agent must infer from the name that this is the scene-level inspection call distinct from blender_status or blender_object_info.

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 behavioral burden, and it does disclose two useful traits: the UI-open prerequisite and that the result is an image. It omits whether the call mutates state (implicitly read-only), image format, and 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 short sentences, front-loaded with the purpose before the precondition. Nothing is padded, though the extreme brevity is part of why parameter and behavioral detail are missing.

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?

There is no output schema and no annotations, so the description should do more; it covers the output type and prerequisite but leaves the one parameter unexplained. Adequate for a trivial capture tool, but with clear gaps.

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

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

The single parameter max_size has 0% schema description coverage, and the description never mentions it at all. An agent cannot learn from either source whether it is a pixel bound, a byte cap, or what the default 1024 applies to.

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?

States a specific verb and resource ('Screenshot of the Blender 3D viewport'), which is distinct from the render-oriented siblings in concept. However, it never explicitly contrasts itself with blender_render or blender_render_scene, so an agent must infer that this captures the viewport rather than a rendered 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 parenthetical '(needs the Blender UI open)' is a genuine precondition that tells the agent when this call will succeed. There is no guidance on when to prefer this over blender_render/blender_render_scene, nor any statement of what happens if the UI is closed.

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 safety burden, and it does flag the critical destructive behavior: reset=True clears other bones first — and the schema default is true, so this is destructive by default. It doesn't cover error behavior for unknown bones or whether the write is undoable, so it is strong but not complete.

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?

Three tightly packed sentences, front-loaded with the core action and payload shape before the reset caveat and the follow-up tool. Every clause earns its place.

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

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

For a 3-param mutation tool with no annotations, no output schema, and a nested object, the description covers the tricky parts (payload shape, destructive reset default, recovery via reset_pose). Missing only armature semantics and failure modes.

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 nested rotations format and the reset flag semantics well, but says nothing about the required 'armature' string parameter, leaving one of three parameters undocumented.

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?

States a specific verb (Set) and resource (local Euler rotations on pose bones), specifies units (degrees), and gives the exact payload shape (rotations={"bone": [x, y, z]}). It also names the sibling it complements (blender_reset_pose), so an agent can distinguish it from pose-related neighbors.

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?

Gives useful operating context: reset=True clears other bones first, and blender_reset_pose is named as the way back to rest. It stops short of routing the agent against other pose siblings like blender_pose_aim or blender_key_pose, so it is clear context without explicit exclusions.

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. It does disclose real behavior: it blocks until the socket answers, is idempotent when already running, and resolves blender.exe from Program Files or $BLENDER_EXE. It omits what happens on timeout, what error a failure yields, and whether a partially started process is left behind.

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?

Three short sentences, front-loaded with the core action and blocking behavior. The executable-discovery sentence is useful but arguably incidental detail for a caller; otherwise there is no 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?

For a two-parameter lifecycle tool with no annotations and no output schema, the description covers the blocking and idempotency semantics but leaves the timeout parameter, failure modes, and the relationship to blender_open/blender_status unexplained. Adequate but with clear gaps.

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

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

Schema description coverage is 0% and the schema gives no titles or descriptions beyond type/default. The description explains only blend_file as an optional file to open; the timeout parameter is never mentioned, so its unit, effect, and failure consequence are 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?

States a specific verb and resource ('Launch Blender') plus the blocking condition ('wait until the addon socket answers'), which is more precise than the bare name. However, it does not distinguish itself from the sibling blender_open, which plausibly overlaps in intent, leaving an agent to guess between them.

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?

Provides one useful usage condition — 'No-op if it is already up' — which tells the agent an idempotent call is safe. It gives no guidance on when to prefer blender_start over blender_open or what to do if startup fails, so usage is only implied, not framed.

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 behavioral burden. It implies a read-only probe but does not disclose side effects, whether it attempts to launch Blender, what the result looks like (boolean vs error), or latency/timeout 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?

A single, front-loaded question with zero wasted words. Nothing could be trimmed without losing 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?

For a trivial zero-parameter probe, the description is close to adequate, but with no output schema and no annotations it leaves the return semantics and safety profile unspecified. Minimum viable 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; the schema is trivially complete. Baseline 4 applies for a no-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 names the specific target (Blender's MCP addon socket) and the specific check (reachability right now), which is far more concrete than the bare name 'blender_status'. It is clear it is a connectivity probe, though it doesn't explicitly flag itself as distinct from the start/stop lifecycle 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?

There is no guidance on when to call this versus blender_start or blender_stop, nor any stated precondition (e.g. 'call before other tools to verify Blender is running'). The implied use is a health check, but the agent must infer 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 behavioral burden. It discloses the key trait an agent needs: a guard that blocks shutdown on dirty state, and that force=True is destructive ('kills it'). It stops short of stating what 'kills' entails (data loss extent, signals, return behavior), but it is far above the average unannotated mutation 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?

Two short sentences, front-loaded with the action and immediately followed by the failure condition and its override. Zero 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?

For a one-parameter lifecycle tool with no output schema and no annotations, the description covers the essentials: what it does, when it refuses, and the destructive override. Slightly more on what force actually does to unsaved work would make it airtight.

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 'force' on its own, and it does: force=True bypasses the unsaved-changes refusal at the cost of killing the process. That is genuine semantic content beyond the bare boolean/default 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?

States a specific verb and resource ('Quit Blender') with no ambiguity, and is trivially distinguishable from siblings like blender_save, blender_open, and blender_start. An agent knows exactly what this tool does without opening the schema.

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 conveys the operative usage condition: the tool refuses when the file has unsaved changes, and force=True overrides that. This tells the agent when the call will fail and how to route around it, though it does not explicitly name an alternative (e.g., blender_save) for the unsaved-changes case.

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 behavioral burden. It does disclose one genuinely useful trait — that jumping to a frame evaluates existing keyframes — but omits that this is a state mutation (it changes the scene's current frame), whether partial input is allowed, and what happens to keyframes when fps changes.

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 front-loaded sentence with no filler. It is slightly dense with slashes and "and/or", but every clause carries 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 four-parameter, no-annotation, no-output-schema tool, the description is minimal but not empty. It leaves out whether the tool requires an active Blender session, whether changes are persistent/saved, and how partial parameter combinations are handled.

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 for four undocumented parameters. It does map loosely onto them (frame range = start/end, fps = fps, frame = frame), but never explains the null defaults, valid ranges, or how start/end interact when only one is supplied.

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 names a specific verb set ("Set", "jump to") and resources ("frame range", "fps", "frame"), so the agent knows this controls timeline state. It is distinguishable from sibling tools like blender_render or blender_key_pose, though it bundles three distinct operations into one sentence without separating them.

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?

There is no statement of when to use this tool versus alternatives, nor any precondition (e.g., Blender must be running, a scene must be loaded). The parenthetical "which evaluates existing keyframes" hints at a side effect but gives no guidance on when that matters.

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 and does well: it discloses that solid/wireframe skip the GPU guard, that the scene is restored after rendering, and that execution is refused while ComfyUI runs a job or VRAM is low unless ignore_gpu_guard is set. Remaining gaps are engine/timeout behavior and whether a partial failure still writes images.

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?

Front-loads the core action and orientation convention, then uses a compact mode enumeration and two short behavioral sentences. The mode block is dense but each clause carries information; no filler sentences.

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 an 8-parameter tool with 0% schema coverage and no output schema, the description covers the two most consequential parameters (mode, ignore_gpu_guard) and the light value, but leaves views, elevation, size, engine, and timeout undefined in both schema and prose. An agent can call it at defaults, but cannot confidently tune resolution, view count, or camera pitch.

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 mode's five values and the light parameter's role as a temporary offset key light, but says nothing about size, views, engine, timeout, or elevation despite them materially affecting output. Partial compensation only, so a 3 rather than higher.

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?

States a precise verb and resource ('Render evenly spaced turntable views of all visible meshes') and adds a concrete semantic anchor ('View 0 = front (-Y)') plus a return statement ('returns the images'). This clearly distinguishes it from blender_render, blender_render_scene, and blender_screenshot, which lack the orbit/turntable framing.

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?

Gives actionable selection guidance for the mode parameter (material/solid/wireframe for speed, normal/mask for data) and states the conditions under which it refuses plus the escape hatch (ignore_gpu_guard=True). It stops short of explicitly naming a sibling alternative, e.g. when to prefer blender_render_scene or blender_screenshot over this, so it is clear but not fully 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, the description does disclose meaningful behavior: what is checked, that asset_json triggers a sidecar cross-check, that non-manifold is bounded, and that an environment variable must be configured. It does not state that this is a read-only operation, what the pass/fail output looks like, or how the default tool reports failures.

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?

Terse and front-loaded — the core action and its check list come first, optional sidecar behavior second, prerequisite last. The parenthetical enumeration is dense but each clause carries information; no 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?

For a six-parameter validation tool with no annotations and no output schema, the description covers the checks and most parameters but omits what the validator returns (report shape, exit/status semantics) and how defaults like tol=0.02 and nonmanifold_max=0 affect outcomes, leaving an agent to infer result handling.

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 carries the burden and mostly succeeds: tol relates to the height_m dimension check, tri_budget caps triangles, nonmanifold_max bounds non-manifold edges, and asset_json enables sidecar cross-checking. Only glb_path is left unexplained, and it is self-evident.

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?

States a specific verb+resource (run the asset validator) and enumerates the exact checks performed: dimensions vs height_m tolerance, tri budget, NaN, zero-area faces, non-manifold geometry, PBR maps. No sibling tool performs validation, and the description makes the tool's role 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?

Implicitly scopes usage (validate an exported asset, optionally with its sidecar via asset_json) and notes the ASSET_VALIDATOR_PY prerequisite, but gives no explicit when/when-not guidance or workflow ordering relative to siblings like export_glb or compare_ref.

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