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

The description discloses the core mutation—creating/reusing a material and assigning it—but does not explain what happens when the material name already exists, whether existing material assignments are overwritten, or what the state-changing consequences are beyond the obvious. The annotations are all false and do not provide a safety profile, so the description carries the full burden and leaves important behavior unspecified.

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

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

Two sentences with no filler. The first sentence front-loads the core operation, and the second quickly gives the one important semantic convention for color inputs.

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 10 parameters, no output schema, minimal property descriptions, and no meaningful annotations, the description is too thin. It omits how material reuse works, whether existing assignments are replaced, error behavior for missing targets, and semantics for several optional material properties.

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

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

Schema description coverage is only 30%, so the description must compensate, but it only adds the color-space note 'linear RGBA in [0,1]'. It does not explain the meaning of transmission, emission_strength, material_name, target selection, or how alpha relates to base_color's alpha channel.

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 action—'Create or reuse a basic Principled BSDF material and assign it to an existing mesh'—with a clear resource and scope. It also naturally distinguishes itself from every sibling tool, none of which handle material assignment.

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

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

The phrase 'assign it to an existing mesh' gives a clear usage context: this tool is for modifying or applying materials to objects already present in the scene. It does not explicitly name alternatives or exclusions, but no sibling offers the same material-assignment capability, so the guidance is adequate.

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

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

Annotations provide no safety or idempotency information (all hints false), so the description must carry the behavioral burden. It only lists parameters and does not disclose that it mutates the current scene, whether the operation is reversible, or how it affects subsequent renders. No contradiction with annotations, but little behavioral context beyond the word 'Configure'.

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 compact sentence with no filler; the primary action and settings are front-loaded, and every phrase maps to a set of parameters in the schema.

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

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

For a tool with eight required parameters, no output schema, and no annotation help, the description is too thin. It leaves out what 'bounded' means operationally, why engine variant matters, and what state the call produces; the schema can enforce constraints but cannot supply the workflow context an agent needs.

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

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

With schema description coverage at 0%, the description needed to compensate for all eight parameters but only maps them at a category level. It does not explain the difference between BLENDER_EEVEE and BLENDER_EEVEE_NEXT, what 'transparent' affects, inclusive timeline bounds, or the practical meaning of sample counts.

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 has a specific verb ('Configure') and resource ('Eevee render scene') and enumerates exactly what is set: resolution, samples, transparency, FPS, timeline range. It reads as a scene-level counterpart to sibling tools like blender_configure_world, though it does not explicitly call out which sibling it is not.

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 implied: use when the task is to set bounded Eevee render-scene parameters. However, there is no explicit when-to-use/when-not-to-use guidance or mention of alternatives (e.g., configure_world for world settings, render for output), leaving the agent to infer placement in the workflow.

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

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

With all annotations set to false, the description carries the full burden of behavioral disclosure. It states that this is a mutation ('Set') but does not explain side effects, whether the operation is idempotent, how it interacts with existing world settings, or what happens after the change. No behavioral context beyond the bare action is provided.

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

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

A single sentence that is direct, front-loaded, and free of filler. It states the action, target, and value format efficiently, making it easy for an agent to parse quickly.

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

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

For a two-parameter tool with no output schema and no annotation hints, the description is adequate for basic invocation but not fully complete. It omits usage guidance, behavioral side effects, and meaningful semantics for the strength parameter. The tool is simple enough that these omissions are not catastrophic, but a more robust description would improve completeness.

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

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

The schema already documents the color parameter as 'Linear RGB color [r, g, b]', so the description's repetition of 'linear RGB' adds little for color. For strength, the description attaches it to the background but does not clarify its meaning, units, or allowed interpretation beyond the schema's minimum of 0. With 50% schema coverage, the description partially compensates but leaves strength underdefined.

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'), a specific resource ('Blender World background color and strength'), and the value format ('linear RGB values'). This clearly distinguishes the tool from siblings like blender_set_light and blender_configure_scene, which target different scene elements.

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

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

The description implies the tool should be used when the agent needs to change the Blender world background color or strength. However, it does not explicitly state when to prefer this tool over alternatives, nor does it mention any exclusions or prerequisites. The usage context is inferable but not explicitly guided.

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

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

It discloses the core behavior of creating and activating a camera, and notes unit conventions, which adds some context beyond the sparse annotations. However, it does not describe side effects such as whether the active camera is changed, how existing cameras are affected, or what happens if a camera with the same name 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, efficient sentence with the primary action front-loaded. It packs the key unit information without wasted words or redundancy.

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

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

For a six-parameter mutation tool with no output schema and minimal annotations, the description is only partially complete. It covers units and look_at behavior but omits the meaning of the active and collection parameters and the exact activation side effect, leaving an agent to guess important execution details.

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

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

With schema description coverage at only 33%, the description partially compensates by stating that location is in meters, focal_length is in millimeters, and look_at accepts a target point or object name. But it repeats schema information for location/look_at and leaves name, active, and collection semantically 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 opens with 'Create and activate a camera,' a specific verb and resource that clearly identifies the tool's action and object. This distinguishes it from sibling tools like blender_create_primitive and blender_set_point_light, and the extra unit details reinforce its domain.

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

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

The description implies when to use the tool—when a camera needs to be created and activated—but gives no explicit context, exclusions, or comparison with alternatives. It does not state, for example, when to choose this over configuring an existing camera or placing a light.

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 adds context beyond annotations by specifying units (meters) and cyclic behavior (closed loops). However, it does not disclose side effects such as creating a new object in the scene or any destructive potential, and annotations are all false, so the description carries more burden but falls short of full disclosure.

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

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

The description is compact, consisting of three sentences that front-load the action and resource, then provide essential unit and behavioral details without extraneous 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 tool with 12 parameters and no output schema, the description is adequate but not complete. It clarifies core concepts (units, cyclic) but omits guidance on parameters like fill_mode, bevel_resolution, and semantic_type, and does not mention that the tool creates a new scene object, which an agent might need to know.

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

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

With only 25% schema description coverage, the description compensates partially by explaining that bevel_depth is in meters and that cyclic creates closed loops, which the schema does not describe. However, it does not clarify other parameters like fill_mode, curve_type, or bevel_resolution beyond the schema's minimal descriptions, leaving gaps.

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 action ('Create') and resource ('general 3D polyline or Bezier curve'), and distinguishes it from a logo generator, making its purpose unambiguous. It also implies a distinction from sibling tools like blender_create_primitive without naming them directly.

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 clarifies the tool is for general curves, not logo generation, giving context on appropriate use. However, it does not explicitly name alternatives like blender_create_primitive or state when not to use this tool, so guidance is clear but not fully explicit.

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

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

The annotations are all false and provide no behavioral context, so the description carries the burden. It adds useful non-obvious behavior: units are meters, rotation is Euler radians, dimensions define final physical size and override scale for meshes, and the light object applies only to point_light. It does not mention possible name conflicts or return values, but it gives more than a minimal viability threshold.

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-load the purpose and then pack in the non-obvious constraints. Every sentence earns its place, and there is no redundant restating of schema facts.

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 creation tool with no output schema, the description plus the input schema cover the core create action, units, and a key scale-vs-dimensions behavior. Gaps remain: what happens on duplicate names, what collection/display_size/semantic_type mean, and what the tool returns after creation. These may be partially self-evident, but not fully specified.

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 around 50%, so the description must compensate for missing parameter explanations. It does add semantics for dimensions/scale precedence and the light/point_light dependency, and reinforces units. However, several parameters such as collection, display_size, semantic_type, and the primitive enum values are left unexplained in both schema and description, so compensation is incomplete.

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

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

The description opens with the specific action and resource: 'Create one allowlisted Blender primitive.' This clearly identifies the tool as creating primitive objects and distinguishes it from sibling creation tools like blender_create_curve and blender_create_camera. The allowed-set notion mirrors the primitive enum, so an agent can tell what it is for 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?

There is no statement of when to use this tool versus alternatives such as blender_set_light, blender_set_point_light, blender_create_curve, or blender_create_camera. The only condition mentioned, 'light is valid only for point_light,' is a parameter-level constraint, not guidance for tool selection. The agent has to infer usage from the tool name and sibling list.

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

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

With all annotation hints false, the description carries the behavioral burden and does add real value: it names the artifact root, indicates the snapshot is a .blend file, and states that it includes a scene fingerprint and UUID inventory. It does not disclose overwrite behavior or side effects on object UUIDs, but the core write behavior and artifact placement are clearly conveyed.

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

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

The description is one front-loaded sentence with no filler; every phrase adds information about the snapshot's location and contents. It loses a point only because the compactness leaves out parameter-level detail.

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

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

For a snapshot tool with three optional but undocumented parameters and no output schema, the description is incomplete for invocation beyond the no-argument case. An agent still lacks the meaning of provenance parameters, whether a snapshot_id is auto-generated when omitted, and what the tool returns or confirms after creation.

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 does not explain snapshot_id, source_turn, or source_action_id. The body text mentions snapshot content but never connects any parameter to its meaning or required format, so an agent cannot determine what values these optional fields should take.

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

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

The description states a clear verb and resource: create a restorable .blend snapshot under CODEX3D_ARTIFACT_ROOT, with specific content (canonical scene fingerprint, stable object UUID inventory). It is unambiguous about what the tool does, but it does not explicitly differentiate from the sibling blender_save_checkpoint, so it stops short of 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 guidance is given on when to use snapshot creation versus alternatives such as blender_save_checkpoint or blender_restore_snapshot, nor is there any prerequisite such as an open scene or existing object IDs. The only implied usage is 'create a snapshot,' but the when/when-not distinction is absent.

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

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

Annotations already declare destructiveHint=true, and the description aligns by stating 'Delete'. It adds the nuance that only the named object is affected and unrelated objects are untouched, which is additional context beyond the annotation. However, it doesn't disclose failure modes or reversibility, so it only partially adds value.

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

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

Two sentences, minimal waste, the core action is front-loaded. The clarifying note is useful and not redundant.

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 delete tool with destructive annotations, the description provides essential scope and target information. It doesn't cover error handling or return values, but given the simplicity and annotation coverage, it's largely sufficient.

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

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

Schema coverage is 0%, so the description must clarify the parameter. It does so by specifying the object is identified by name and that it must be an existing object. This adds meaning beyond the bare string schema, though it doesn't detail exact matching rules.

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 (delete) and resource (Blender object) with scope qualifiers (exactly one, by name). The second sentence clarifies it doesn't clear unrelated objects, distinguishing it from broader scene-clearing operations.

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

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

The description clearly indicates the tool's purpose for single-object deletion, but it doesn't explicitly contrast it with alternatives like blender_delete_snapshot or provide when-not-to-use conditions. It has clear context but lacks 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?

The destructiveHint annotation already signals destructive behavior, and the description adds meaningful specificity: it explicitly states that both the snapshot .blend file and its metadata record are deleted from the configured artifact root. This tells the agent exactly what collateral is affected. It does not mention permissions or irreversibility, but the annotation lowers the burden.

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

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

The description is a single concise sentence with no filler. The key facts—what is deleted and from where—are front-loaded, and every word contributes to the 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 one-parameter destructive tool with a destructiveHint annotation and no output schema, the description covers the essential context: the artifact deleted, the metadata record removed, and the storage location. The only notable gap is the absence of a pointer to list_snapshots for obtaining valid IDs, but the tool is simple enough that this is a minor omission.

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 tool description never explains snapshot_id beyond the implication of 'one snapshot'. It does not state that the ID must correspond to an existing snapshot or point to blender_list_snapshots for discovering valid IDs. The parameter name and pattern are somewhat self-explanatory, but the description fails to compensate for the lack of schema documentation.

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

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

The description opens with 'Delete one snapshot .blend and metadata record', a specific verb plus a clear resource, and it distinguishes this tool from siblings like blender_delete_object by specifying that both the .blend file and the metadata record are removed. The operation is unambiguous and accurately reflected by the tool name.

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 such as blender_create_snapshot, blender_restore_snapshot, or blender_delete_object. It does not mention that list_snapshots can provide a valid snapshot_id or that this tool should not be used for deleting scene objects. Usage context 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?

Annotations already reveal destructiveHint=true, and the description adds meaningful behavioral details: actions are ordered, fail-fast, and the tool inspects the final scene afterward. This goes beyond the annotations, though it doesn't cover partial-failure or rollback 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?

Two sentences with no filler, front-loading the core behavior and then summarizing supported action families. The category list is compact but slightly redundant with the schema enum, keeping this from a perfect score.

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 destructive tool with 16 action types, no output schema, and no per-action parameter definitions, the description is too sparse. It hints that the final scene is inspected but doesn't clarify the return format, failure behavior, or how to compose a valid batch action object.

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

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

Schema description coverage is 0%, and the description does not explain how to construct valid parameters objects for any action type or what the metadata/description fields mean. It only lists supported action categories, which is too little guidance for the actions array parameter.

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 an ordered batch of allowed Action objects and then inspects the final scene. This specific verb-plus-resource framing distinguishes it from the many single-action sibling tools like blender_create_primitive or blender_transform_object.

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 batch framing and the enumerated action categories imply this is for composing multiple actions in one ordered run, but the description never explicitly says when to prefer it over calling individual sibling tools or when not to use it. Usage guidance is mostly implied 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?

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds value beyond that by stating the default compact behavior, warning that full mode should be used sparingly, and disclosing that the tool returns the current fingerprint and accepted snapshot metadata. This is useful behavioral context without contradicting the annotations.

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

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

Three sentences, no filler, and the most important information (default mode) is front-loaded. Every sentence adds either a capability, a filtering option, or a usage constraint.

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 inspection tool with five optional parameters and no output schema, the description covers the core call decisions: default mode, available filters, full-mode tradeoff, and high-level return contents. It could go deeper on what 'accepted snapshot metadata' means and what the compact summary actually contains, but nothing essential for selecting or invoking the tool is missing.

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 does map all five parameters in prose: mode (compact/full), collection, scene name, object UUID, and semantic group. However, it leaves some semantics shallow—'semantic group' and the exact effect of combining filters are not explained—so it is strong but not fully complete.

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 clear verb ('Inspect') and resource (Blender scene) and immediately distinguishes the tool by defaulting to a compact collection-oriented summary. It also lists concrete filter dimensions, which makes the tool's role obvious relative to siblings like blender_ping or blender_list_snapshots.

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

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

The description provides explicit conditional guidance: use full mode only when all object transforms are genuinely needed, implying compact mode is the default and safer choice. It does not explicitly name sibling alternatives or exclusion cases, but the filter and mode instructions give clear context for when this tool is appropriate.

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

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

Annotations provide no safety hints (all flags false), so the description must carry the burden of disclosing side effects. It mentions that animation is evaluated by Blender Timeline and that cycle adds a cycles modifier, but it does not disclose whether existing keyframes are overwritten, whether the operation is idempotent, or whether it requires specific object types or selection. The disclosure is incomplete for a mutating operation that inserts keyframes.

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 exactly two sentences with no filler. The core purpose ('Insert transform and/or Principled emission-strength keyframes') is front-loaded, and the behavioral note about cycle is appended efficiently. Every clause earns its place, making it highly scannable for an agent.

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

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

Given the tool has 4 parameters, a nested keyframes array, and no output schema or safety annotations, the description is severely insufficient for correct invocation. It does not explain what target_name refers to, the structure of keyframes entries, units for transforms (meters/radians – hinted in schema but not here), the role of interpolation, or behavior on success/failure. The description fails to compensate for the 0% schema coverage and the tool's inherent complexity.

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

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

Schema description coverage is 0% – no property descriptions exist in the schema, so the tool description is the only source for parameter meaning. The description does not explain any of the parameters: target_name, keyframes array structure, frame, location, rotation, scale, emission_strength, cycle, or interpolation. The names are somewhat self-explanatory but the description adds zero semantic detail, leaving the agent to guess formats, units, or required fields beyond the schema's minimal constraints.

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 ('Insert') and names the resource ('transform and/or Principled emission-strength keyframes'), which clearly distinguishes this as an animation tool rather than a static transform tool. It also mentions the cycle modifier behavior, further clarifying its scope. The purpose is immediately apparent and distinct from siblings like blender_transform_object.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like blender_transform_object or other animation tools. It does not mention prerequisites, when not to use it, or any scenarios where a sibling would be preferred. The only hint is 'cycle adds a cycles modifier when supported,' which is behavioral, not usage guidance.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the scoping detail ('configured artifact root') and confirms no arguments are needed, which is useful but minimal. It does not disclose return format, ordering, or whether the list is empty-safe, but with strong annotations this is acceptable.

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

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

The description is two short sentences with zero waste. The core action and scope are front-loaded, and the no-arguments note is a useful clarification. 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 zero-parameter, read-only list tool with strong annotations, the description is nearly complete. The only minor gap is not describing the return format (e.g., names, IDs, timestamps), but since there is no output schema and the tool is simple, this is a small omission. The sibling context (blender_restore_snapshot, blender_delete_snapshot) makes the listing purpose clear.

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 is trivially complete (100% coverage). The description explicitly states 'Takes no arguments,' which removes any ambiguity about whether hidden or optional parameters might exist. This is a case where the description adds value by confirming the absence of parameters.

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

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

The description states a specific verb ('List') and resource ('snapshots stored inside the configured artifact root'), which clearly identifies the tool's function. It does not explicitly differentiate from sibling tools like blender_restore_snapshot or blender_delete_snapshot, but the read-only listing intent is unambiguous.

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

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

The description implies usage context by specifying the scope ('configured artifact root') and noting it takes no arguments, which tells the agent it can be called without preparation. However, it does not explicitly state when to prefer this over alternatives like blender_restore_snapshot or blender_delete_snapshot, nor does it mention any prerequisites like needing a configured artifact root.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds context that the bridge is 'authenticated' and 'localhost', and that it reports versions—details not provided by annotations. This enriches the behavioral understanding without contradicting any annotation.

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, focused sentence that conveys the purpose and argument count with no filler. It is appropriately front-loaded, stating the action first. Every word adds value, making it an exemplar of conciseness.

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

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

For a simple, parameterless ping tool with no output schema, the description is sufficiently complete. It identifies the target (localhost Blender bridge), the operation (check), and the result (connector/backend versions). A minor gap is that it doesn't specify the format or meaning of 'versions', but given the simplicity and lack of alternatives, this is acceptable.

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 is empty with 100% coverage trivially. The description explicitly states 'Takes no arguments', confirming the lack of input requirements. Per the rubric, a baseline of 4 is appropriate for a zero-parameter tool, and the description reinforces this clearly.

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 explicitly states the verb 'Check' and the specific resource 'authenticated localhost Blender bridge', and specifies it reports connector/backend versions. This clearly distinguishes it from all sibling tools, which are scene/object manipulation or snapshot operations. No ambiguity remains.

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

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

The description implies the tool is a quick health/connectivity check (similar to a network ping) and notes it takes no arguments, but it does not explicitly state when to use it versus alternatives (e.g., before other operations, to verify bridge status). Since no sibling tool serves this purpose, there is no alternative to contrast, but the description could still offer a hint about when to invoke it (e.g., 'Run this first to ensure connectivity').

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 idempotentHint=true and destructiveHint=true, the annotations already signal mutation behavior; the description adds useful detail that the operation does not rename objects or change geometry. It does not discuss what happens to existing codex3d_uuid values, but the idempotency hint partially covers repeat 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?

Two sentences with no filler. The primary action and target are front-loaded, and the non-destructive clarification is kept to a single trailing clause.

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 a simple mutation and idempotency annotation, the description gives enough to select and invoke confidently. Minor gaps remain around return/confirmation behavior and behavior when no objects match the prefix, but these are not blocking for a tool this simple.

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 only parameter, prefix, has 0% schema coverage and minimal constraints, so the description bears the burden of explaining it. The phrase 'with an explicit name prefix' establishes that prefix selects objects by name, which is meaningful beyond the schema. It could clarify matching semantics, but for a single string parameter this is adequate.

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

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

The description uses a specific verb ('Assign') and names the exact target ('stable codex3d_uuid properties') and selection condition ('legacy objects with an explicit name prefix'). It also differentiates from nearby siblings like blender_rename_object by explicitly stating it does not rename or modify geometry.

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 provides a clear trigger condition: use when legacy objects share an explicit name prefix and need stable uuid properties. It does not explicitly list alternatives or exclusion cases, but among the siblings only this tool is for ID reconciliation, so the context is sufficient.

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 adds a genuine side-effect disclosure beyond the annotations: after success, the old name no longer resolves. This warns agents that existing references using the old name will break. It does not cover error handling or name conflicts, but the key mutation consequence is made clear.

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

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

The description is two short, purposeful sentences with no filler. The primary action is front-loaded, and the side effect follows immediately.

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 two-string-parameter rename, the description gives the action, the existing object requirement, and the main post-condition. The lack of output schema and error condition details is not crippling at this complexity, though uniqueness constraints are unaddressed.

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. The 'old name' phrase helps infer that target_name is the current object name and new_name is the replacement, but no naming rules, uniqueness constraints, or validation details are given.

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: 'Rename an existing Blender object.' It also clarifies the salient outcome ('The old name stops resolving after success'), which distinguishes renaming from sibling operations like transform or delete.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description never references alternative tools or conditions, so an agent is left to infer when renaming is the right choice from the tool name alone.

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

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

Beyond the annotations, the description discloses the output contract: only validated relative paths and render statistics are returned, and still PNGs may additionally be delivered as MCP image content. It does not mention render cost or file overwrite behavior, but annotations already cover idempotency and non-destructiveness.

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

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

Two sentences, no filler, with the core behavior and return contract front-loaded. Every clause adds useful information that is not already present in the annotations or schema.

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 sparse schema and no output schema, the description adequately covers output formats, destination root, and return value shape. It omits execution prerequisites and explicit file-writing side effects, but for a two-parameter render tool the essential guidance is present.

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

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

The schema has 0% description coverage, so the description must compensate. It maps 'kind' to still PNG versus animation MP4 and ties 'path' to a relative location under CODEX3D_ARTIFACT_ROOT. It does not explicitly state the expected file extension or whether path refers to the output file, but the meaning is reasonably inferable.

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 ('Render'), the target resource ('Blender scene'), and the exact output formats ('PNG' and 'MP4'), plus the artifact root. This clearly separates blender_render from sibling tools like blender_inspect_scene or blender_create_snapshot.

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 purpose implies when to use it—when a still or animation render is needed—but there is no explicit when-not-to-use guidance or mention of alternatives. The sibling tool list is not leveraged to route the agent away from similar tools.

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

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

The description discloses key behaviors beyond the annotations (all false): it creates a non-overwriting pre-restore safety snapshot and returns an inspection and scene diff. This adds valuable context about side effects and output. It does not contradict the annotations, and while it omits potential failure modes, it covers the main behavioral aspects adequately.

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, compact sentence that leads with the core purpose and then adds necessary operational details. There is no redundancy or filler, and the structure is clear and front-loaded.

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

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

For a complex mutation tool with no output schema and no useful annotations, the description provides a good overview but leaves gaps: it does not describe the exact structure of the 'inspection' or 'scene diff', does not explain error conditions (e.g., fingerprint mismatch), and does not specify the return format. These are important for an agent to call it correctly without additional inference.

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

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

The schema has no parameter descriptions (0% coverage), so the description must explain all parameters. It clarifies that current_fingerprint and snapshot_fingerprint are the 'live' and 'target' fingerprints, but it does not explain snapshot_id, its purpose, or its relationship to the fingerprints. This partial explanation does not fully compensate for the lack of schema documentation.

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

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

The description clearly states the tool's purpose: it restores a snapshot registered by the current session, and explicitly notes it is reversible and creates a safety snapshot. This is a specific verb+resource and distinguishes it from sibling tools like blender_create_snapshot, blender_list_snapshots, and blender_delete_snapshot.

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 a condition ('Requires the live and target fingerprints') but provides no guidance on when to choose this tool over alternatives. It does not mention scenarios where a different snapshot operation (e.g., create, delete) would be more appropriate, nor does it state prerequisites like the snapshot must be from the current session beyond the phrase 'registered by the current session'.

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 adds meaningful behavioral context beyond the annotations: it never overwrites an existing file and verifies that saving did not change the live scene. These details are not already present in readOnlyHint, destructiveHint, or idempotentHint, and they do not contradict the annotations.

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

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

Two dense sentences, with the core action first and the critical safety behaviors second. Every clause earns its place and there is 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 one-parameter tool, the essential behavior is covered: create, version, never overwrite, verify live scene. However, with no output schema and no usage guidance relative to the many snapshot-related siblings, the description leaves some selection and invocation ambiguity.

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 only defines 'path' as a non-empty string, and schema description coverage is 0%. The description says the deliverable is placed under CODEX3D_ARTIFACT_ROOT and is versioned, which gives some context, but it does not clarify whether 'path' is relative to that root, an absolute path, a file name, or how existing paths are handled.

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 action ('Create a new, versioned .blend delivery') and a clear location ('under CODEX3D_ARTIFACT_ROOT'), so the core purpose is unambiguous. It does not explicitly distinguish itself from the sibling blender_create_snapshot, though the artifact-root and versioned-delivery wording hints at a difference.

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 about when to call this tool versus alternatives such as blender_create_snapshot, blender_list_snapshots, or blender_restore_snapshot. No exclusions, prerequisites, or decision criteria are provided, so the agent must infer usage from the name and description.

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

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

Annotations establish that this is a mutating but non-destructive operation. The description adds useful context by stating the light must already exist and that size is optional, which implies a missing target is likely an error. However, it does not say whether unspecified properties are preserved or how 'size' behaves on a Point light.

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 worded sentence with no filler, front-loading the operation and target before listing the affected properties. 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 simple update tool with one required parameter and no output schema, the description covers the main target, updatable fields, and optionality. It is minimally complete but leaves gaps around usage versus the sibling tool and the exact behavioral effect of the update.

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

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

Schema description coverage is only 25%, so the description partially compensates by naming color, energy, and size, and by implying target_name via 'existing'. It does not add units for energy, clarify target_name semantics beyond existing, or add meaning beyond what the schema already gives for color.

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

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

The description states a clear action ('Update'), the target resource ('an existing Point or Area light'), and the affected properties (color, energy, optional area size). It is specific enough for an agent to understand the tool's purpose, though it does not explicitly differentiate itself from the similarly named sibling blender_set_point_light.

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 about when to use this tool versus alternatives such as blender_set_point_light. The description does not mention when the tool should be avoided, what it cannot do, or which light types are not supported.

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?

All annotation hints are false, so the description carries the transparency burden. It does disclose one meaningful behavior beyond the schema: world transform is preserved by default. However, it does not explain what happens when keep_transform is false, whether changes are reversible, or what side effects parenting has on the scene beyond the hierarchy change.

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 the action front-loaded and the key default behavior attached as a qualifier. Every word contributes meaning; there is no redundant or filler language.

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

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

For a simple parenting operation, the description plus meaningful parameter names may be enough to make a basic call. However, with no annotations, no schema descriptions, and no output schema, the missing details about keep_transform=false behavior and edge cases leave an agent guessing at important behavior. It is adequate but not fully complete.

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

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

Schema description coverage is 0%, and the description does not explicitly define target_name, parent_name, or keep_transform. The phrase 'one existing object to another' and the word 'default' hint at the parameter roles, but the agent must infer which object is the child and which is the parent, and the exact effect of keep_transform=false is not documented.

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 action, 'Parent', on a clear resource, 'one existing object to another', and adds a distinct behavioral nuance: world transform preservation by default. This clearly distinguishes it from sibling tools such as blender_transform_object and blender_rename_object.

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 intended use is inferable from the verb and resource, and 'existing object' implies a prerequisite that objects must already exist. However, there is no explicit guidance about when to prefer this tool over alternatives, no exclusions, and no mention of how this relates to scene organization or transform-oriented 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?

Annotations only cover read-only, idempotence, and destructiveness; the description adds that the target must already exist and clarifies value semantics. However, it does not disclose failure behavior, whether unspecified fields remain unchanged, or any prerequisites beyond existence.

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 carry the action, target, and parameter semantics without filler. The key differentiator ('point-light object') is front-loaded.

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

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

For a simple three-parameter mutation with no output schema, the description covers core call semantics and parameter meaning adequately. It is slightly thin on edge cases like missing targets or partial-update behavior, but those are minor gaps.

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

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

Schema coverage is low (33%), but the description compensates by adding meaning: 'linear RGB [0,1]' and 'non-negative Blender watts' go beyond the bare schema constraints. target_name gets no extra detail, but its purpose 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?

The description names a specific verb ('Update'), a specific resource ('point-light object'), and the exact fields affected ('color and/or energy'). This is clear and distinguishes it from create/delete siblings, though it does not explicitly contrast with blender_set_light.

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

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

The description implies the tool is for modifying an existing point-light object, but gives no explicit when-to-use guidance or alternative-routing. With blender_set_light as a sibling, an agent gets little help deciding 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?

Annotations are all false, so the description carries the behavioral burden. It adds useful partial-update behavior and unit semantics, but it does not clarify what look_at does to rotation, how supplied fields interact, or what happens for unknown targets. Informative but not comprehensive for a mutating 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?

Three short sentences, each carrying distinct information: operation scope, targeting preference, and units. No filler, redundancy, or irrelevant context.

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

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

Covers the main decision points: partial update, target selection, and units. However, the semantics of look_at, interaction between supplied fields, and error behavior for missing targets are left under-specified, and there is no output schema to compensate.

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?

Adds meaning beyond the schema: scale is unitless (the schema's repeated array descriptions incorrectly say distances/radians), dimensions are meters, rotation is Euler radians, and target_uuid is preferred over target_name. This is especially valuable because several schema property descriptions are copy-pasted and misleading.

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 'Update only supplied transform fields', a specific verb and resource with a clear partial-update scope. The transform focus differentiates it from sibling animation, hierarchy, and material tools even without naming 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 useful targeting guidance ('Prefer stable target_uuid; target_name is a readable fallback') but does not state when to choose this tool over alternatives such as blender_keyframe_object or blender_set_parent, nor any exclusion conditions. Usage context is mostly implied rather than explicit.

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