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 implies a mutation (adding a bone) but does not disclose potential side effects, failure conditions (e.g., duplicate bone name, missing armature), or whether the operation modifies the scene destructively. It also doesn't mention return values or errors. The description only restates parameter purposes without behavioral context.

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

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

The description is a single, clear sentence followed by a bulleted parameter list. It is front-loaded with the action, and every line serves a purpose. No redundant or filler content. The structure is easy to scan and 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 simple mutation tool with five parameters and no output schema, the description covers the parameters but misses important context: it doesn't state whether the armature must already exist, how the bone is positioned in 3D space, whether parent_bone is optional, or what happens if the bone_name conflicts. It also doesn't explain the default behavior of head and tail when null. These gaps leave room for misuse, so the description 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 is the only source of parameter meaning. It provides a concise explanation for each parameter (e.g., 'head: [x, y, z] bone head position'), adding value beyond the schema's type and title. However, it lacks details like units, coordinate system, or behavior when head/tail are omitted (default null), so it doesn't fully compensate for the schema's lack of descriptions.

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

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

The description states 'Add a bone to an armature' – a specific verb and resource, clearly distinguishing it from siblings like create_armature (which creates the armature) and add_bone_constraint (which adds constraints to bones). No ambiguity about what this tool does.

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

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

The description gives no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., that the armature must already exist), nor does it cross-reference related tools like create_armature or add_bone_constraint. The user must infer usage from the name and context.

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

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

No annotations are provided, so the description carries full behavioral burden. It only states the action itself, without disclosing whether constraints are appended or replace existing ones, whether pose mode is required, or what happens with invalid or missing target_name.

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 short, front-loaded docstring with a one-line purpose followed by a clear argument list. No wasted words, though it could be slightly more structured.

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

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

For a 4-parameter tool with no annotations and no output schema, the description omits critical operational details: when target_name is required, whether it operates on edit/pose bones, and how existing constraints are affected. An agent is likely to call it incorrectly without additional 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%, and the description compensates by explaining each parameter: armature_name, bone_name, constraint_type with examples, and target_name. It does not explain defaults or conditional requirements, but the basic semantics are 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?

Clear verb+resource: 'Add a constraint to a bone.' The name and description distinguish it from sibling add_object_constraint by explicitly mentioning bone. However, it does not contrast with other bone-related siblings like setup_ik_chain.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites (e.g., armature existence), and no hint that target_name is conditionally required for certain constraint types.

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, but it only restates the action and lists parameters. It does not disclose side effects, whether the simulation is added as a modifier or property, whether the object must be a mesh, or how this interacts with existing physics.

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

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

The description is appropriately short and front-loaded with the purpose, followed by a compact argument list. No filler or redundant content is present.

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

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

For a five-parameter mutation tool with no annotations and no output schema, the description is incomplete. It does not explain what 'adding cloth simulation' actually does, what prerequisites exist, or what the agent should expect after invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all five parameters and adds some meaning, including a numeric range for quality_steps (1-20). However, tension and compression are described near-tautologically as 'Structural tension' and 'Structural compression', and units or behavioral effects are not explained.

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 operation and resource: 'Add cloth simulation to an object.' This cleanly identifies the tool's function and distinguishes it from sibling tools like add_rigid_body and add_fluid_physics by naming the unique simulation type.

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 about when to use this tool instead of alternatives such as add_rigid_body, add_fluid_physics, or bake_physics. There are no exclusions, conditions, or contextual hints beyond the tool's 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 the full burden of behavioral disclosure. It states the operation (add) and the parameter semantics, but it doesn't disclose side effects (e.g., whether an existing color attribute with the same name is replaced or errors), whether the operation is destructive, or what the return value is. 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?

The description is compact and front-loaded with the main purpose, followed by a concise parameter list. Every sentence earns its place, and the format is scannable. It loses one point because the parameter list is somewhat redundant with the schema, but it's still efficient.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't mention what happens on success/failure, whether the color attribute is created empty or with default values, or how it interacts with existing attributes. An agent would need to infer or experiment to know the full behavior. The parameter semantics are covered, but the behavioral context 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 explain all four parameters (object_name, name, domain, data_type) with brief semantic notes, including the enum-like values for domain and data_type. However, it doesn't add much beyond what the schema already shows (e.g., defaults are in the schema, and the description just restates the options). It's adequate but not rich.

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

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

The description clearly states the tool's function: adding a color attribute (vertex color layer) to a mesh. It distinguishes itself from the sibling set by naming the specific resource (mesh color attribute) and the operation (add). It doesn't explicitly name a sibling alternative, but the verb+resource combination is specific enough to differentiate it from tools like set_vertex_color or assign_material.

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 target object and the domain/data_type options, but it doesn't explicitly state when to use this tool versus alternatives like set_vertex_color or enter_vertex_paint. The parameter descriptions give some context, but there's no explicit when/when-not guidance or mention of prerequisites (e.g., the mesh must exist).

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 absent, so the description carries the full burden of behavioral disclosure. It only states the basic action of adding fluid simulation, with no mention of side effects, prerequisites, or behavior on existing simulations. The term 'EFFERENT' appears to be a misspelling of 'EFFECTOR', potentially misleading the agent.

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

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

The description is concise, with a clear one-sentence purpose followed by a compact arg list. It is front-loaded and contains no unnecessary words. The structure is efficient and easy to scan.

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

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

Given the absence of annotations and output schema, the description is incomplete. It doesn't explain the meaning of domain_type values, prerequisites (e.g., object type), or what happens to existing physics. The agent may need additional domain knowledge to use this tool correctly.

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

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

The description lists each parameter with allowed values (e.g., domain_type: DOMAIN, EFFERENT, FLOW, COLLISION; fluid_type: LIQUID or GAS), adding meaning beyond the bare schema which has no property descriptions. However, it doesn't explain what each domain_type value represents (e.g., what DOMAIN vs FLOW means), and the apparent typo reduces clarity. It provides basic value constraints but not full semantic depth.

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

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

The description states a specific verb and resource: 'Add fluid simulation to an object.' It clearly conveys the tool's purpose and distinguishes it from other physics tools like add_rigid_body and add_cloth_physics, though it doesn't explicitly name alternatives. The 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?

No guidance is provided on when to use this tool versus alternatives such as add_rigid_body or add_cloth_physics. There are no conditions, exclusions, or context cues. The agent is left to infer applicability without explicit advice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Add' and lists arguments; it does not state whether a new object is created, how the active selection is affected, whether repeated calls stack force fields, or what the tool returns. This is a shallow behavioral profile 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?

The description is compact, but not every line earns its place. The name, strength, and flow lines mostly restate the parameter names, adding little value. The genuinely useful enum and location-format details are buried in an Args block rather than being highlighted.

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

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

This is a minimal viable description: it names the action and documents every parameter at a basic level, so a simple call can be constructed. But with no annotations and no output schema, it omits important context such as coordinate-space meaning, units, force-field behavior, and whether any cleanup or follow-up is needed.

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 add meaning. It does add useful information: the field_type value list and the [x, y, z] location format. But 'strength: Field strength' and 'flow: Field flow' are tautological, no units or effect semantics are provided, and the 'etc.' enum list is incomplete and contains the typo 'LENARD_JONES'.

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

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

The description opens with a specific verb and resource: 'Add a force field effect.' This clearly identifies the operation and differs from physics siblings like add_rigid_body or add_cloth_physics. However, 'effect' is slightly vague about whether this creates a standalone force-field object or modifies an existing simulation.

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 about when to use this tool versus related tools. It does not mention physics contexts, mention alternatives like create_particle_field, or state any prerequisites or exclusions. The agent is left to infer usage entirely 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 no annotations, the description carries the full burden of behavioral disclosure. It states the core mutation (adding a node) but does not mention prerequisites (e.g., whether node_group_name must already exist), side effects like automatic connections, or return values.

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

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

The description is short and front-loaded with the core purpose. The Args block is a bit redundant with the schema, but it is structured and free of fluff.

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

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

For a simple 3-parameter tool, the description covers the basic invocation, but omits important operational context such as whether the node group must already exist, what happens when location is absent, and what is returned. It is minimally viable 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 document parameters. It names all three parameters and adds useful examples for node_type (e.g., 'MeshPrimitiveCube') and specifies location format as [x, y]. However, node_group_name is only repeated as 'Node group name' with no additional context.

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 and resource: 'Add a node to a geometry node tree.' This distinguishes it from sibling tools like add_geometry_nodes_modifier and connect_geometry_nodes, though it does not explicitly call out the 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?

No guidance is provided about when to use this tool versus alternatives such as connect_geometry_nodes or add_geometry_nodes_modifier. The intended context is only implied by the tool 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?

No annotations are provided, so the description carries the full burden. It only says 'Add a geometry nodes modifier', implying a mutation but not disclosing side effects, prerequisites (e.g., object existence), or behavior beyond the action. It does not mention whether existing modifiers are affected or what happens to the object.

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

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

The description is extremely concise and structured with a clear action line and a simple argument list. It avoids unnecessary verbosity, but the brevity comes at the cost of informativeness. It is appropriately front-loaded with the purpose.

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

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

This is a mutation tool with no output schema and no annotations. The description is too sparse to be complete; it lacks any mention of prerequisites, return values, error conditions, or how this tool integrates with other geometry node operations. The agent would need to infer most 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%, so the description must fully explain parameters. It merely restates the parameter names with minimal elaboration: 'object_name: Target object' and 'node_group_name: Name for the node group'. These are nearly tautological and do not clarify the role of the node group or any default behavior.

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

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

The description states a specific action 'Add a geometry nodes modifier to an object', which clearly identifies the verb and resource. However, it does not distinguish itself from the sibling tool 'add_geometry_node', which could be confused. The meaning is clear but lacks differentiation.

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 use this tool versus alternatives like 'add_geometry_node' or 'connect_geometry_nodes'. The description only states what it does, leaving the agent to infer appropriate usage without explicit conditions or 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 of behavioral disclosure. It reveals that camera binding is possible but does not clarify side effects such as whether binding changes existing camera behavior, whether markers are additive, or whether existing markers can be duplicated. Core add behavior is clear, but behavioral depth is thin.

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

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

One purpose sentence plus a three-line Args list, with no filler and no repetition of schema defaults. The action is front-loaded and every line adds needed 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 simple three-parameter creation tool, the description documents purpose and all parameters, and the lack of an output schema lowers the need for return-value explanation. Gaps remain in usage routing and behavioral side effects, 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?

The schema has no parameter descriptions (0% coverage), so the Args section carries full weight. It gives each parameter a semantic gloss: marker name, frame number, and optional camera binding. It does not explain frame indexing or units, but every parameter is usable from the description alone.

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

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

Description opens with 'Add a timeline marker', a specific verb and resource, and adds its two use cases: animation notes or camera binding. The resource is unambiguous and pairs naturally with the sibling remove_marker, so an agent can distinguish add_marker from removal or navigation tools.

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

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

No explicit when-to-use or when-not-to-use guidance is provided. The description does not mention alternatives such as remove_marker for deletion or go_to_frame for navigation, leaving the agent to infer suitability 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?

No annotations are provided, so the description must disclose behavior. It only states the action and lists parameters, but does not mention side effects (e.g., whether the modifier is appended to the stack, if it fails on missing objects, or if it is destructive). It also does not describe the return value or any requirements like object 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?

The description is concise: one sentence for the purpose plus a structured Args block. It is front-loaded and each sentence adds value. The examples are useful without being 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?

For a tool with varied modifier types and no output schema or annotations, the description is minimal. It covers the basic purpose and parameters but omits important context such as modifier stack behavior, error conditions, or any return value. It is adequate for simple usage but incomplete for complex scenarios.

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 provides meaningful explanations for all four parameters, including concrete examples for 'params' (e.g., SUBSURF and BEVEL settings). This goes beyond the bare schema and gives the agent actionable guidance.

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 the verb 'Add' and the resource 'modifier' clearly, and lists valid modifier types. However, it does not explicitly differentiate from sibling tools like configure_modifier or apply_modifier, so it lacks the explicit sibling distinction that would earn 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?

The intended usage is implied: you use this tool when you want to add a new modifier to an object. There is no explicit guidance on when to prefer this over alternatives such as configure_modifier or add_geometry_nodes_modifier, nor any exclusions or 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, the description carries the full burden. It only states the action and parameter meanings, but does not disclose requirements like existing track/object, error behavior, or whether the operation is reversible. It also doesn't mention if the strip replaces existing strips or any side effects.

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

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

The description is concise, with a one-line purpose and a parameter list. It avoids unnecessary fluff and is easy to scan. However, the structure is a simple docstring without highlighting important prerequisites or notes.

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

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

The tool has 8 parameters, no output schema, and no annotations. The description only covers the basic operation and parameter meanings, omitting any context on expected inputs (e.g., that the track must exist), return values, or error handling. An agent would need more guidance to use this tool reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It provides brief descriptions for all 8 parameters, such as 'object_name: Target object' and 'blend_type: REPLACE, ADD, SUBTRACT, MULTIPLY.' However, these are minimal and lack details on constraints or default behaviors beyond the schema's defaults.

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

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

The description states a specific action: 'Add an animation clip (strip) to an NLA track.' This clearly identifies the verb and resource, and distinguishes it from sibling add_nla_track by specifying the strip addition to an existing track.

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

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

The description does not mention any conditions for when to use this tool versus alternatives. It lacks exclusions or references to other tools, leaving the agent without guidance on selecting it over related NLA operations.

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

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

With no annotations, the description must fully disclose behavior, but it only states that a track is added. It does not explain side effects, whether an existing track with the same name is replaced, failure conditions, or what happens if the object lacks animation 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?

The description is brief, front-loaded, and uses a clean Args format. It avoids fluff and is easy to scan, though the parameter list partially duplicates 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?

This is a mutation tool with no annotations and no output schema envelope. The description provides the minimum for calling it but lacks information about naming constraints, existing track behavior, prerequisites beyond 'animation data,' and expected return or failure outcomes.

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 does provide short semantics for both parameters: object_name is 'Target object with animation data' and name is 'Name for the new track.' This adds some meaning beyond the raw schema but leaves edge-case behavior 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?

The description states a clear verb-resource pair: 'Add an NLA track to an object' and adds context ('for layering animation clips'). This is enough to distinguish it from the sibling add_nla_strip, though the distinction is not explicitly named.

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 use this tool versus add_nla_strip or other animation tools. The only context clue is 'Target object with animation data,' which implies a prerequisite but does not state when to choose this over alternatives.

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 present, so the description is the sole source of behavioral information; it conveys the operation type but discloses no side effects, constraint-stack behavior, required target relationships, or error conditions. Since this is a mutating tool, more behavioral context is needed beyond 'Add a constraint'.

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

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

The description is well-structured with a purpose sentence, a useful type list, and a labeled Args block; there is no filler. It is a bit long, but each line earns its place by documenting a parameter.

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 with no annotations and no output schema, the description gives a workable but incomplete picture: it omits which constraint types require target_name/subtarget, how settings values map to Blender properties, and any validation behavior. It is enough for a simple call but not for reliable advanced use.

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 Args list is essential; it adds meaning for all six parameters, especially subtarget ('bone name for armature targets') and the enumerated constraint types. However target_name is only restated as 'Target object', and allowed settings keys/property names are left unspecified.

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

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

The first sentence states the exact operation ('Add a constraint to an object') and the list of common constraint types gives concrete scope. Combined with the object_name parameter, this clearly distinguishes it from sibling add_bone_constraint and other constraint-related tools.

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

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

No guidance is given on when to use this tool over add_bone_constraint, remove_object_constraint, setup_ik_chain, or other constraint tools. The description implies usage for object constraints but never states exclusions or alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention side effects, whether existing particle systems are replaced or appended, object type requirements, or any limitations beyond the operation itself.

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

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

The description is short, front-loaded with the main purpose, and uses a clean argument list with no filler. Every sentence and phrase 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?

With no annotations and no output schema, the description still lacks important contextual details such as expected behavior on failure, whether multiple particle systems can be added to the same object, and what success looks like. Parameter semantics are covered, but broader call context is incomplete.

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

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

Schema description coverage is 0%, so the description must add parameter meaning, and it does: it explains 'particle_type' options, specifies frames for lifetime and frame range, and identifies the target object. This is helpful, though each parameter's explanation is brief and mostly restates the parameter name.

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 and resource: 'Add a particle system to an object.' This clearly identifies the tool's core function, but it does not differentiate it from the sibling tool 'create_particle_field', so it does not fully earn 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?

There is no guidance about when to use this tool versus alternatives, no prerequisites, and no exclusion criteria. The description only states what the tool does, leaving the agent to infer appropriate usage.

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 bears the full burden of behavioral disclosure. It states that rigid body physics is added, which implies mutation, and clarifies body_type semantics (ACTIVE vs PASSIVE), but it does not disclose side effects, prerequisites (e.g., object must exist), or whether adding physics alters existing simulation state. The description is too sparse to fully inform the agent of the operation's consequences.

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

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

The description is compact and front-loaded with the core purpose, followed by a clean Args list. Every line adds necessary information with no filler. It is well-structured 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?

Given the tool's moderate complexity (5 parameters, no output schema, no annotations), the description covers all parameter semantics and states the core purpose. However, it leaves out usage context such as when to choose rigid body over cloth or fluid physics, and what happens after calling it. For a straightforward physics-add operation, this is mostly sufficient but not exhaustive.

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 fully compensate, and it does. Every parameter is explained beyond the schema: object_name is the target, body_type maps to dynamic vs static/kinematic, mass has units (kg), and friction and restitution have explicit ranges. This is exactly the semantic enrichment needed.

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

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

The description states a specific verb and resource: 'Add rigid body physics to an object.' This clearly differentiates it from sibling tools like add_cloth_physics and add_fluid_physics, as the tool name and description specify the exact physics type. The purpose is immediately understandable and not vague or tautological.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention when rigid body physics is appropriate, whether it should be used with active objects, or that it can be paired with bake_physics or removed with delete_physics. An agent is left to infer the use case 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only states the action and parameters; it does not mention side effects, whether the node is created unconnected, failure behavior if the material is missing, or idempotency. For a mutation tool, this is a significant gap.

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

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

The description is compact and front-loaded: a one-sentence operation summary followed by a tight Args list. Every element earns its place, and there is no redundant prose or repetition of 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?

The description is adequate for basic invocation: the core parameters are explained and the action is clear. However, without annotations or an output schema, it misses important context such as whether the new node is connected, whether the material must pre-exist, and what a successful call returns. This leaves it minimally viable 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?

The schema has 0% description coverage, but the Args section compensates well by explaining material_name, node_type with concrete examples, the [x, y] location format, and the optional name label. This adds real meaning beyond the raw schema, though it stops short of enumerating all valid node types or units.

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: 'Add a shader node to a material's node tree.' It clearly differentiates from sibling tools like connect_shader_nodes and set_shader_node_value by focusing on the creation of a new node rather than wiring or modifying one.

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 explicit guidance on when to use this tool versus alternatives such as connect_shader_nodes, set_shader_node_value, or create_material. It implies that you use it when you want a new shader node, but it does not state prerequisites (e.g., the material must already exist) or exclude related 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?

With no annotations provided, the description carries the full burden. It discloses the auto-creation of the Basis key and the 'from_mix' behavior, which adds useful context. However, it doesn't mention error handling (e.g., invalid object type), behavior if the name already exists, or return values. Partial coverage.

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

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

The description is concise: two sentences plus a compact argument list. Purpose is front-loaded and there is no fluff. It could be improved by structuring the parameter explanations more formally, but it is efficient and easy to parse.

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

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

Given no output schema and no annotations, the description covers the core purpose, parameters, and a key behavior (auto-creating Basis). It lacks explicit error handling, interaction with existing keys, and confirmation of mutation. For a straightforward add operation, it is mostly complete but not exhaustive.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does: object_name is 'Target mesh object', name is 'Name for the new shape key', from_mix is 'Create from current mesh state'. This adds meaning beyond the schema's types and defaults, though it could be slightly more detailed (e.g., what 'from current mesh state' implies).

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

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

The description clearly states the action: 'Add a shape key (morph target) to a mesh object.' It specifies the resource (mesh object) and the auto-creation of Basis key. While it doesn't explicitly contrast with sibling tools like set_shape_key_value or remove_shape_key, the verb and resource are specific and unambiguous.

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

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

No guidance on when to use this tool versus alternatives. It doesn't mention that this is for creating new keys while others are for setting or removing, nor does it describe any prerequisites or context. The description simply states the function without differentiating usage scenarios.

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 behavioral burden. It explains that align_location, align_rotation, and align_scale match the target's corresponding properties, but it does not disclose whether the operation modifies the object in place, uses world vs. local coordinates, or how errors are handled. Some behavioral info is present, but not comprehensive.

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

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

The description is concise, with a one-line summary followed by a clear list of arguments. It is front-loaded with the main purpose and contains no extraneous information, making it easy to scan.

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

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

The description covers the tool's purpose and all parameters, which is sufficient for calling it correctly. However, it lacks usage guidance and some behavioral details (e.g., world vs. local transforms, side effects). For a simple alignment tool, this 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%, but the description explicitly explains each parameter: name (object to align), target (reference object), and the three alignment booleans with their meanings. This fully compensates for the lack of schema descriptions, providing clear parameter semantics.

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 ('align') and resource ('one object's transform to another'), making it clear what the tool does. It distinguishes from siblings like move_object, rotate_object, and scale_object by indicating a combined alignment operation rather than a single-axis transform.

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

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

No explicit guidance on when to use this tool versus alternatives such as set_object_transform or snap_to_cursor. The description does not mention exclusions, prerequisites, or recommend this over other tools, leaving usage context implicit.

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

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

No annotations are provided, so the description carries the full burden. It transparently states the output: a structured defect report with counts and affected element indices. The verb 'analyze' implies a non-destructive read operation, and no side effects are mentioned. It does not explicitly state that the mesh is not modified, but the return-oriented phrasing makes this implicit. This is sufficient for a simple analysis tool.

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

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

The description is two sentences, front-loaded with the action and defect enumeration, followed by the return format. Every sentence earns its place with no fluff or repetition. It is appropriately sized for the tool's simplicity.

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

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

The description covers the core behavior, enumerates what defects are checked, and describes the return value (counts and indices). With no output schema, this is sufficient. It does not mention edge cases like invalid object names or non-mesh objects, but those are minor gaps for a tool of this complexity.

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

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

The input schema has one parameter (object_name) with no description, and schema description coverage is 0%. The description does not mention the parameter directly, but the phrase 'Analyze mesh' implies that object_name refers to a mesh, adding a semantic type beyond the raw schema. This partially compensates for the coverage gap, though it could be more explicit.

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 names the resource (mesh), the action (analyze for defects), and enumerates specific defect types (non-manifold edges, loose vertices, zero-area faces, duplicate vertices, wire edges, twisted faces). This clearly distinguishes it from general mesh statistics or production readiness checks, and from siblings like find_duplicates which target a single defect type.

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 a clear use case: identify and report mesh defects. However, it does not explicitly state when to prefer this tool over related siblings such as fix_mesh_defects, find_duplicates, or check_production_readiness, nor does it mention any prerequisites or exclusions. The context is clear but not fully differentiated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the basic action but does not explain side effects, whether a new material is created, whether an existing material is overwritten, what happens if the image path is invalid, or what the tool returns. The material_name argument hints at some behavior but leaves key details implicit.

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

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

The description is short and front-loaded with the core purpose. The argument list is compact and follows the schema closely without unnecessary filler. It could be slightly more informative, but it stays concise and scannable.

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

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

Given no annotations, no output schema, and a large sibling set, the description is under-specified. It omits important context for correct invocation: whether UV mapping is required, whether a fallback material is created, how material_name interacts with existing materials, and what success or failure looks like. The tool is simple but still needs more behavioral 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%, so the description must compensate. It does provide brief explanations for all three parameters: object_name, image_path, and material_name. These add meaning beyond the bare schema titles, but the explanations are minimal and lack useful constraints such as supported image formats, path expectations, or material-name resolution behavior.

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

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

The description clearly states the operation: 'Apply an image texture to an object.' It names a specific verb, resource, and target. It is clear enough to be understood, but it does not explicitly distinguish itself from nearby material-related siblings like create_procedural_material or assign_material.

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. It does not mention prerequisites, common workflows, or conditions where another tool like create_procedural_material or assign_material would be more appropriate. The intended use is only implied by the tool's name and short 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?

With no annotations provided, the description carries the full responsibility for behavioral disclosure. It says 'bake deformation,' hinting at permanence, but does not explicitly warn that the operation is irreversible or destructive, nor does it state what happens to the modifier after baking (remains, removed, etc.). For a mutation tool, this is a significant transparency gap.

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

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

The description is extremely concise, with a clear purpose statement followed by a structured Args section. There is no wasted text; every sentence earns its place. It is front-loaded with the core function and uses a format that makes parameter mapping easy for the 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?

For a simple 2-parameter tool, the description might seem sufficient, but it lacks critical context for a destructive operation. It does not mention the irreversible nature of baking, the state of the modifier afterward, or relations to sibling tools like apply_modifier. Given the absence of annotations and output schema, the description is incomplete for an agent to fully predict the tool's effects.

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

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

The schema has 0% description coverage, so the description's parameter explanations are essential. It clearly defines object_name as 'Target object with lattice modifier' and modifier_name as 'Name of the lattice modifier,' adding meaning beyond attribute names and types. However, it doesn't elaborate on defaults or behavior, which the schema partially covers via the default value for modifier_name, so it doesn't reach a 5.

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 exactly what the tool does: 'Apply lattice modifier to bake deformation into mesh.' It identifies the specific resource (lattice modifier) and the outcome (bake deformation), distinguishing it from generic modifier tools like apply_modifier or create_lattice. This is a clear, unambiguous purpose.

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

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

The description implies the tool is for objects that already have a lattice modifier, but it provides no explicit guidance on when to use this versus the generic apply_modifier or other sibling tools. It does not mention any prerequisites beyond the modifier existing, nor does it state when not to use it. The usage context is clear but not contrasted with alternatives.

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 says the modifier is 'baked' into the mesh, hinting at a permanent change, but it does not disclose that applying a modifier is destructive or that it collapses the modifier stack. There is no mention of error conditions, required object type, or undo behavior.

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

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

The description is short and front-loaded with the core purpose. The Args section is clean and easy to scan, and there is no filler content. It earns its place without unnecessary 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 mutation tool with no annotations and no output schema, the description is too sparse. It provides enough information to attempt a call but omits important behavioral context such as irreversibility, prerequisite modifier existence, and applicable object types. This makes it incomplete for safe and correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. Both parameters are listed with brief descriptions ('Target object' and 'Name of the modifier to apply'), but these mostly restate the parameter names and add little constraint detail. It does not explain that modifier_name must reference an existing modifier or that the object must support that modifier.

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 ('Apply (bake)') and a clear resource ('a modifier into the mesh'). This makes the tool's action unambiguous and distinguishes it from related modifier tools like add_modifier or configure_modifier. However, it does not explicitly call out how it differs from 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?

No guidance is given about when to use this tool versus alternatives such as add_modifier, configure_modifier, or remove_modifier. The usage context is only implied by the verb 'apply' rather than explicitly stated. There are no prerequisites or exclusions mentioned.

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

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

With no annotations, the description carries disclosure responsibility. It does add the key behavioral fact that world position is preserved while transform values reset, which is more transparent than a bare 'apply'. However, it does not mention whether the operation is destructive to object data, affects children or constraints, or requires a particular mode.

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 one-line core behavior is front-loaded and the argument list is compact with no boilerplate. Every sentence earns its place and the structure is easy to scan.

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

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

For a 4-parameter tool with no annotations and no output schema, the description covers the core operation but leaves usage context and parameter behavior implicit. It is a minimum viable definition, adequate for straightforward calls but with clear gaps around side effects and when to use 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 parameter descriptions needed to carry weight, but they mostly restate the property names: 'location: Apply location.' The glosses don't explain how true/false toggles each component or the implication of leaving a channel off, leaving the agent to infer behavior from defaults alone.

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/resource pair ('Apply (bake) transforms') and states the exact effect: resets values to identity while keeping world position. This makes it clearly distinct from sibling move/rotate/scale/set_object_transform tools, even though it does not name 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?

The baking/reset-to-identity wording implies a typical use case, but the description never says when to choose this over set_object_transform, move_object, rotate_object, or scale_object. It offers no exclusions or alternative routing, so an agent must infer the applicable context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action 'assign.' It does not reveal whether an existing material in the slot is replaced, what happens with an invalid slot index, or whether the material must already exist in the scene.

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, front-loaded with the core action, and organized cleanly into an Args list. No unnecessary prose is present, though the brevity contributes to the lack of behavioral 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 3-parameter mutation tool with no output schema and no annotations, the description is too thin: it lacks failure behavior, side effects, prerequisites, and any note about whether the slot index is zero-based. An agent could call it with an existing material and destination slot, but it would not know what to expect when the material or slot is invalid.

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 Args section needed to add real meaning. However, 'material_name: Material to assign' and 'slot: Material slot index' mostly restate the parameter names, while 'object_name: Target object' adds only minimal clarity. It also omits that slot is optional with a default of 0, which is already in the schema but not explained.

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 opening sentence, 'Assign a material to an object's material slot,' names a specific verb, resource, and target. It is clearly distinct from create/delete/set-material tools, though it does not differentiate itself from the similarly named sibling reassign_material_slot.

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 about when to use this tool versus alternatives such as reassign_material_slot, set_material_property, or create_material. There is no mention of preconditions like the material needing to already exist, or exclusions for other workflows.

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 behavioral burden. It explains what the tool does at a high level but does not disclose side effects, such as whether existing vertex weights are overwritten, whether the target object must be a mesh, or what happens if the vertex group does not exist.

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

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

The description is compact and front-loaded: a one-sentence summary of the operation followed by a labeled argument list. Every line adds necessary information, and there is no redundant or speculative content.

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

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

All parameters are described, making the tool minimally callable, but the description omits important operational context for an annotationless mutation tool: prerequisites, effects on existing assignments, possible failure modes, and return 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%, so the Args section is the only semantic source. It meaningfully explains all four parameters: object_name is the target object, group_name names the vertex group, vertices are vertex indices, and weight is explicitly constrained to 0.0-1.0. This fully compensates for the schema's lack of descriptions.

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

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

The description states a specific action ('Assign vertices to a vertex group') with a clear resource and an additional scoping detail ('with a specific weight'). It is immediately distinguishable from sibling tools like create_vertex_group or assign_material, which target different resources or 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?

No when-to-use guidance is provided. The description does not mention whether the vertex group must already exist, whether this tool is the right choice only after create_vertex_group, or when an alternative would be preferable. The agent must infer usage purely from the name and operation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does convey the output contents in detail (what metrics and issues are returned) and implies a read-only analysis by calling it a 'report.' However, it does not explicitly state that the tool makes no scene modifications or clarify any side effects or performance implications. It covers the return value well but stops short of explicit safety/efficacy 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 short and front-loaded with the core purpose on the first line, followed by an itemized return list that is easy to scan. Minor redundancy exists: 'compact format' in the first line is restated by 'All in a single compact response' at the end, which could be trimmed without loss.

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 zero-parameter tool with no output schema and no annotations, the description gives a solid account of the returned fields, which is the main thing an agent needs to call it. It falls short on contextual completeness because it does not explain how this report differs from several overlapping sibling analysis tools (get_scene_summary, analyze_mesh_quality, get_mesh_statistics), leaving the agent to guess which one is appropriate.

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 and the schema is empty with 100% coverage, so there is nothing for the description to disambiguate on inputs. Per the baseline for zero-parameter tools, the description appropriately adds value by detailing what the caller should expect in the output rather than explaining parameters.

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

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

The description clearly states the tool performs a full scene analysis and reports quality metrics with a specific verb-target ('auto_scene_report' = analyze scene). It enumerates the exact contents of the report (poly count, material count, lighting, camera, bounding box, non-manifold/ngon issues), which is specific and useful. However, it does not differentiate from close siblings like get_scene_summary, analyze_mesh_quality, or get_mesh_statistics, which likely overlap in scope.

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

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

There is no guidance on when to use this tool versus its siblings. Several sibling tools (get_scene_summary, analyze_mesh_quality, check_production_readiness, get_mesh_statistics) appear to offer similar reporting/analysis functions, yet the description gives no indication of how the agent should choose among them. No exclusions, prerequisites, or alternative routing are provided.

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

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

No annotations are provided, so the description must disclose side effects. It only says 'Bake physics simulation,' without mentioning that baking is often destructive (replaces dynamic simulation with keyframes), may take time, or requires the object to have an active physics simulation. The param description hints at 'Object with physics' but does not elaborate on failure 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 sentence states the purpose, followed by a clean list of parameters. Front-loaded and efficient with no wasted words.

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

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

For a simple bake operation, the description covers the essential parameters but omits behavioral details such as irreversibility, time cost, and required preconditions (object must have physics). Given no annotations or output schema, a bit more context 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 provides no property descriptions (coverage 0%), but the description explains all three parameters clearly: object_name, frame_start, and frame_end. Each has a concise meaning that adds value beyond the schema's bare types and defaults.

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

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

States a specific verb ('bake') and resource ('physics simulation for an object'). This clearly distinguishes it from siblings like delete_physics or add_rigid_body, which handle different aspects of physics.

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

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

No guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., object must already have physics) or contrast with similar operations like add_rigid_body or delete_physics. The agent must infer usage context.

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

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

There are no annotations, so the description must carry the full behavioral burden. It states the mutation (adds modifiers) and that settings apply to each modifier, but gives no hints about error handling, preconditions, object existence, or whether existing modifiers are affected.

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 opening sentence states the core behavior, and the compact Args section adds necessary parameter guidance without unnecessary padding. Every sentence 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 batch mutation tool with no annotations and no output schema, the description provides enough to call it correctly: what to pass and what the operation does. It lacks failure-mode and return-value details, but those are not essential for basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It explains all three parameters meaningfully: object_names as a list, modifier_type with concrete examples ('SUBSURF, MIRROR, BEVEL'), and settings as an optional dict applied to each modifier.

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 ('Add'), resource ('modifier'), and scope ('to multiple objects in one call'). This clearly distinguishes it from the sibling add_modifier, which applies to a single 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 phrase 'same modifier to multiple objects in one call' makes the batch use case clear and implies it should be chosen when multiple objects need identical modifiers. However, it does not explicitly name alternatives or state when not to use it.

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

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

With no annotations, the description carries full burden. It provides a sample object structure but does not disclose side effects, failure behavior, atomicity, required fields, or limits. It only states the basic mutation without details on how the operation behaves under error conditions.

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

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

The description is concise and well-structured: a one-line purpose, a sample object, and an args list. No unnecessary filler. It could be slightly more compact, but it is efficient.

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 creates multiple objects with no annotations, output schema, or detailed parameter schema, the description is insufficient. It lacks information about required fields, defaults, error handling, return values, or interaction with other tools. The agent may not know how to construct valid objects or handle failures.

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% (schema has no descriptions and uses additionalProperties true). The description adds a concrete example of the expected object structure (type, name, location, scale), which is helpful. However, it does not specify which fields are required or all possible types, so it partially compensates but 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 states 'Create multiple objects in one call', which is a clear verb+resource and implies a batch operation distinct from single-object tools like create_object. It does not explicitly contrast with sibling batch tools, but the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives. It does not mention 'use for bulk creation' or differentiate from create_object or other batch tools like batch_transform or batch_parent. The agent must infer usage context.

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

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

With no annotations, the description must disclose behavior. It only says 'Delete multiple objects', implying a destructive operation but not mentioning any side effects, failure modes, partial deletion, or whether it's undoable. No detail on handling invalid names.

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

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

The description is concise, with two sentences and no filler. The main action 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 batch delete operation with no annotations and no output schema, the description is sparse. It lacks information about error handling, atomicity, and how it relates to other deletion tools, making it incomplete for an agent to call confidently.

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

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

The description explains the 'names' parameter as 'List of object names to delete', which adds meaning beyond the schema's bare array type. However, it doesn't elaborate on formatting, case sensitivity, or whether non-existent names 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 'Delete multiple objects in one call' – a specific verb and resource, clearly distinguishing it from the singular delete_object and other batch_* tools that perform different actions.

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

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

No guidance is provided on when to use this tool versus alternatives like delete_object or other batch operations. There is no mention of criteria such as 'use for bulk deletion' or 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 of behavioral disclosure. It states that the tool applies presets, implying mutation, but does not describe permissions, error handling, partial failures, undo behavior, or what happens when an object or preset is invalid.

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 front-loaded with the core purpose and keeps the example and argument definition compact. The Args section is slightly redundant with the schema but does not add meaningful bloat.

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

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

Given no annotations, no output schema, and 0% schema description coverage, the description must compensate but does not. It fails to explain valid preset values, whether color is optional, behavior on missing objects, or what the tool returns, making correct invocation uncertain.

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 provides no property descriptions and marks items as additionalProperties: true, so the example entry {"object": "name", "preset": "metal", "color": [r,g,b]} adds meaningful structure. However, it does not specify required fields, valid preset names, color format details, or optionality, leaving significant ambiguity.

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

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

The description clearly states the verb and resource: apply material presets to multiple objects in one call. The batch scope distinguishes it from single-object tools like assign_material, though it does not explicitly name alternatives.

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 'to multiple objects in one call' implies a batching use case, but there is no explicit guidance on when to prefer this over assign_material, wizard_batch_materials, or a single assignment tool. No exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It mentions 'keep_transform' in the example, hinting at a behavior, but it doesn't explain what it does, nor does it disclose side effects, error handling, or requirements like object existence. This is a significant 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?

The description is concise, front-loads the purpose, and includes a useful example. It avoids redundancy and is appropriately short for a simple batch operation.

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 no annotations and no output schema, the description is minimal. It covers the basic function and parameter shape, but it lacks details on return values, error scenarios, prerequisites, and the effect of keep_transform. Given the operation's simplicity, a bit more context would be expected.

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

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

With 0% schema description coverage, the description must compensate. It provides an example structure with 'child', 'parent', and 'keep_transform', which adds meaning beyond the schema's generic object array. However, it doesn't explain the semantics of each field (e.g., what keep_transform does), so it only partially compensates.

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: 'Set parent-child relationships' and specifies 'multiple pairs in one call', which distinguishes it from single parenting tools. However, it doesn't explicitly name the sibling tool parent_objects, so differentiation is implicit rather than explicit.

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 batch use via 'multiple pairs', but it provides no explicit guidance on when to use this tool versus alternatives like parent_objects, nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It states the core action and gives the exact input format, but it does not disclose behavior around missing old names, duplicate new names, or whether renaming is atomic. For a simple rename operation this is adequate but not fully transparent.

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

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

The description is compact and well-structured: a one-sentence purpose, a short example, and a minimal args listing. Every part earns its place, and the main purpose 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 one-parameter batch operation, the description gives enough information to make a correct common invocation: provide a list of {old, new} dicts. However, it omits edge-case behavior and naming constraints that could matter when objects share names or don't exist, 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?

The input schema only defines renames as an array of generic objects, providing 0% semantic coverage. The description compensates by specifying the expected dict shape with 'old' and 'new' keys and giving a concrete example. It does not formally define what 'old' and 'new' refer to, but the example and tool purpose make this reasonably clear.

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

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

The description uses a specific verb, 'Rename', and a clear resource, 'multiple objects', and explicitly says 'in one call' to convey batch behavior. This distinguishes it from single-object rename tools like rename_object and from other batch_* siblings. The example entry makes the purpose even more concrete.

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 'Rename multiple objects in one call' clearly establishes when to use the tool: when several objects need renaming at once. It doesn't explicitly name rename_object as the single-object alternative or state when not to use batch_rename, but the context is strong enough that an agent can infer the correct usage.

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 disclosure burden. It communicates that the operation changes selection and shows the replace/names payload, but it never states what 'replace' does, whether selection is cumulative, or what happens with missing names. That leaves a non-trivial behavioral gap.

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

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

The description is compact and front-loaded: the core behavior appears in the first sentence, and the code-block example is easy to scan. Every sentence contributes; 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 tool with one parameter, no annotations, and no output schema, the description should fully specify the group structure and selection semantics. It provides an example, but omits the meaning of 'replace' and any constraints on object names, so the description is not sufficient for reliable invocation in edge cases.

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 only describes 'groups' as an array of arbitrary objects (0% coverage), so the example payload is the sole semantic documentation. It usefully reveals the replace flag and names list, but it never defines the field meanings or requirements, leaving the structure only partially 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?

The description opens with a specific verb-resource pair ('Select multiple groups of objects') and clarifies the batch nature ('in one call'). The example payload reinforces that this is a grouped selection tool, distinguishing it from single-object selection 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?

It explicitly identifies a relevant workflow ('material assignment workflows'), giving an agent a concrete trigger context. However, it never names sibling alternatives like select_objects or states when not to use batch_select, so exclusion guidance is left to inference.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It states it 'sets origins' but does not explain what an origin is, whether it modifies geometry or transform, whether it is reversible, or any side effects. As a mutation tool, it lacks critical behavioral context like irreversibility or required selection 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?

The description is concise, with a clear first sentence stating the purpose, followed by an example and parameter explanation. It is front-loaded and avoids fluff. However, the example could be more explanatory but is still efficient.

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 batch operation with a nested object structure and no output schema, the description is incomplete. It does not explain allowed values for 'origin_type', whether 'name' refers to an object name or identifier, or any constraints on the list. There is no guidance on error handling or return behavior, leaving an agent without enough detail to reliably construct a valid call.

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 provides an example entry '{"name": "Obj", "origin_type": "GEOMETRY"}' and explains the parameter is a list of origin dicts. This adds meaning about the expected structure (keys 'name' and 'origin_type') but does not enumerate possible values for 'origin_type' or clarify the 'name' field, leaving ambiguity.

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 'Set origins for multiple objects in one call' which clearly identifies the action (setting origins) and the scope (multiple objects, batched). It distinguishes itself from the sibling tool 'set_origin' by explicitly mentioning 'multiple objects in one call', so an agent can tell them apart 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?

The description implies usage for batching multiple objects but does not explicitly state when to prefer this over the singular 'set_origin' or when not to use it. There is no mention of alternatives or exclusion criteria, only the phrase 'multiple objects in one call' which serves as a weak usage signal.

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

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

With no annotations, the description must carry behavioral disclosure. It does add one useful trait—'Only provided channels are modified per object'—but it does not state whether changes are permanent, how missing objects are handled, or what the call 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 brief, front-loaded with the core action, and uses a compact code block for the transform format. Every sentence adds value 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 batch mutation tool the input shape is adequately covered, but context is incomplete without annotations or an output schema: there is no mention of object existence errors, return behavior, or side effects beyond the partial-channel 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 coverage is 0%, so the description is the only source of parameter meaning. It compensates by showing the exact per-entry structure with name, location, rotation, and scale, plus the partial-update rule. It still leaves minor details such as number types and required keys implicit.

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

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

The description clearly identifies a batch operation that applies transform updates to multiple objects and includes a precise array entry format. It is distinct from single-object transform tools by emphasizing 'multiple objects in one call,' though it does not explicitly name a sibling alternative.

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 batching but gives no explicit when-to-use guidance, prerequisites, or alternatives. An agent is left to infer when to choose this over set_object_transform, move_object, rotate_object, scale_object, or apply_transform.

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 states the mutation (setting visibility) but does not disclose validation behavior, handling of invalid or missing object names, partial-failure semantics, idempotency, or what the response indicates. For a batch mutation tool this is a meaningful 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?

Compact and efficient: a front-loaded purpose sentence followed by the entry format and an args line. Every sentence earns its place with no filler, though the format example consumes space that could have been used for key semantics.

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-parameter batch tool with no output schema, the description documents the input format adequately to attempt a call. Missing return-value/error behavior and key semantics (hide_render defaults) leave it short of fully specifying the operation, but the call signature is usable.

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 fully document the parameter. It provides the dict structure and an example with keys (name, visible, hide_render), which adds real value. However, it does not explain the meaning of hide_render, whether it is optional, or defaults, leaving the semantics 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?

States a specific verb ('Set') and resource (visibility for multiple objects) with the clarifying phrase 'in one call', which distinguishes it from single-object tools like set_object_visibility and set_collection_visibility. It doesn't explicitly name those siblings, but the batch intent is clear enough to set it apart.

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

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

No guidance on when to use this tool versus its single-object alternatives (set_object_visibility, set_collection_visibility). The description implies batch usage but gives no exclusions, prerequisites, or conditions that would select this over a sibling.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the action and parameters. It does not disclose whether the bevel is destructive, requires edit mode, or modifies the existing geometry in place.

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, front-loads the operation, and uses a clean Args block. Every line contributes either to the tool's purpose or to parameter understanding, with 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 mutation tool with no annotations and no output schema, important context is missing: how edges are selected, whether the object must be in edit mode, units for width, and what the tool returns. An agent cannot fully predict the tool's requirements or side effects.

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

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

Schema description coverage is 0%, so the description partially compensates by naming all three parameters. However, 'object_name: Object name' and 'width: Bevel width' largely repeat the schema titles; only 'segments (1 = flat bevel)' adds meaningful semantic value.

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

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

The first sentence uses a specific verb ('bevel') and resource ('selected edges of a mesh'), making the tool's operation immediately clear. The name is not merely restated, and the scope is narrow enough to distinguish it from broad edge-editing siblings like edit_mesh_edges.

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, no prerequisites, and no mention that edges must be selected beforehand. Despite sibling tools like edit_mesh_edges or apply_modifier, the description never addresses which workflow should call this tool.

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

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

There are no annotations, so the description bears the full burden of behavioral disclosure. It only says the object is modified and the target is used as an operand; it does not disclose whether the operation is destructive, whether a boolean modifier is added, what happens if geometry is non-manifold, or what the result/return state looks like. This is thin for a mutating operation.

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

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

The description is compact, front-loaded with the core action, and uses a clear Args block with one line per parameter. No filler or redundant restatement of the name is present.

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

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

For a 3-parameter tool without annotations or an output schema, the description supplies the essential semantics needed to make a first call: what the tool does and what each argument means. However, it lacks guidance on prerequisites, failure cases, object types, or what the operation changes structurally, leaving notable gaps for reliable invocation.

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

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

Schema description coverage is 0%, but the description compensates by giving each parameter a meaningful one-line role: object_name is the modified object, target_name is the operand, and operation lists the allowed values. This adds real value over the bare schema titles, though it could be richer about object type requirements and the default operation.

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 ('Perform'), a target resource ('boolean operation between two objects'), and lists the three allowed operation kinds. It is distinct from obvious siblings like join_objects or separate_by_material, though it does not explicitly name a sibling to distinguish itself from.

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 listed operation values (UNION, INTERSECT, DIFFERENCE) imply when the tool is appropriate, and 'Object to modify' + 'operand' clarify roles. However, there is no explicit guidance about when to prefer this over alternatives such as join_objects or mesh edit tools, nor any prerequisites or exclusion criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers what is checked and the return shape, and the word 'audit' implies a non-destructive read-only operation. However, it does not explicitly state that the tool modifies nothing, whether it operates on the named object in any special mode, or how failures or missing objects are handled.

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 tightly written sentences with no filler. The opening phrase states the tool's purpose immediately, the comma-separated list efficiently communicates the audit scope, and the return value is stated in the second sentence. Every part 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-parameter, no-output-schema tool, the description provides the essential context: what is checked, what is returned, and the score range. It is slightly incomplete in not clarifying how to interpret the score or how object_name is resolved, but it is otherwise sufficient for a straightforward read-only audit 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 only parameter, object_name, has 0% schema description coverage and the tool description does not elaborate on it at all. The name is self-explanatory at a basic level, but the description adds no guidance about name format, whether the object must be selected, or what happens when the object does not exist. Given the low schema coverage, the description should have compensated but did not.

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

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

The description clearly identifies the tool as a 'full production readiness audit' and enumerates the exact areas it covers (manifold geometry, UV maps, materials, naming conventions, origin alignment). It also specifies the return value (a 0-100 score with breakdown), making it easy to distinguish from narrower analysis siblings like analyze_mesh_quality or get_mesh_statistics.

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

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

The description establishes a clear use case: a comprehensive pre-production/export readiness check. It does not explicitly name when not to use it or compare it to alternatives, but the 'production readiness' framing and scope of checks give the agent enough context to select it appropriately.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Configure' and never states whether this mutates the selected object's material, creates or replaces a material, has prerequisites, or returns anything. This is a significant gap for an apparent 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?

The description is short, front-loaded with its purpose, and the supported-use line earns its place. The Args block is conventional and contains 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 material-mutation tool with no annotations and no output schema, the description omits side effects and prerequisites. An agent can infer parameter meanings but not what happens when the tool is called, making it incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It gives one-line meanings for all four parameters, and color and metallic receive useful ranges, but material_name and roughness are mostly restatements of their names.

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 ('Configure') and a clear resource ('solid body/casing material'), with the 'solid opaque surface' scope helping separate it from glass/display material siblings. It does not explicitly name sibling tools, but the resource and qualifier are distinct enough.

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 'Works for product casings, furniture surfaces, architectural elements' sentence gives application context, but there is no explicit guidance on when to prefer this over assign_material, set_material_property, create_material, or configure_display_material. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the camera must already exist, whether unset parameters are left unchanged or reset to defaults, or what side effects occur. It only says 'Configure,' which implies mutation but provides no detail about the operation's behavior.

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

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

The description is compact and front-loaded with a clear one-line purpose followed by a parameter list. There is no redundant prose. It earns its place, though it could be slightly more structured with grouping of related optical parameters.

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 seven parameters, no output schema, and no annotations, the description is incomplete. It does not explain prerequisites, default behavior for null values, return values, or the effect of each parameter on the final rendered image. An agent would need additional context to invoke it correctly in all cases.

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 list all seven parameters with brief explanations, adding meaning such as 'Focal length in mm' and 'Enable depth of field.' However, it omits units for focus_distance, clip_start, and clip_end, and does not explain valid ranges or the relationship between fstop and depth_of_field.

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: 'Configure camera optical properties.' This clearly identifies the tool's function and distinguishes it from camera creation, framing, and viewport tools. However, 'configure' is somewhat generic and could be more explicit about the fact that it modifies an existing camera.

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

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

The description provides no guidance on when to use this tool versus alternatives like create_camera, set_camera_to_view, or setup_studio_camera. There are no explicit conditions, exclusions, or references to sibling tools. The usage context is only implied by the phrase 'optical properties.'

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 behavioral disclosure burden. It explains that the tool sets dark base color, low roughness, and optional emission, and gives meaningful scale info for emission strength. However, it does not state whether the material must already exist, whether existing values are overwritten, or what the return/side effects are.

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 tightly structured: a one-line purpose, a short behavior summary, usage examples, and a compact Args block. Every sentence adds value, and the core purpose 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 tool with five optional parameters and no output schema, the description covers parameter meaning, defaults, and typical usage. The main gap is lack of clarification around creating vs. modifying materials, and no comparison to set_material_property or configure_glass_material.

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 fully compensates. Every parameter is given a semantic explanation: material_name, color range (0-1), roughness meaning (0.03 = mirror-like), emission_color, and emission_strength scale (0 = off, 1+ = glowing). This enables correct invocation despite the bare schema.

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

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

The description states a specific verb and resource: 'Configure a display/emissive material.' It further clarifies scope with concrete examples like phone screens, monitors, TVs, and HUDs, distinguishing it from sibling material tools such as configure_glass_material and configure_body_material.

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 when this tool is appropriate: for any emissive/display surface. It does not explicitly name alternatives or exclusion conditions, but the use case is unambiguous enough to guide tool selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses that dyntopo is being enabled/disabled and that detail_size affects detail, but it doesn't explain side effects (e.g., mesh modification, performance impact, whether it requires sculpt mode), what happens to existing topology, or how resolution modes behave. This is a significant gap for a mesh-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?

The description is compact and front-loaded with the core purpose. The parameter list is brief and scannable. It earns its place without fluff, though the resolution modes could use a bit more explanation without hurting 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 tool that mutates mesh topology, with no annotations and no output schema, the description is incomplete. It doesn't state prerequisites (e.g., must be in sculpt mode), side effects, or what the resolution modes mean. An agent would struggle to know when and how to invoke this correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It does add meaning for enabled and detail_size, but resolution is only listed as 'RELATIVE, ABSOLUTE, or BRUSH' without explaining what each mode does. The description partially compensates but leaves a key parameter under-explained.

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 configures dynamic topology for sculpting, with a specific verb and resource. It distinguishes itself from sculpt-related siblings like configure_sculpt_brush, enter_sculpt_mode, and remesh_sculpt, though it doesn't explicitly name 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?

The description implies usage in a sculpting context and lists parameters, but it doesn't explicitly state when to use this tool versus alternatives like remesh_sculpt or configure_sculpt_brush. The context is clear enough for an agent to infer, but no exclusions or alternative routing is provided.

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

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

With no annotations, the description carries the full burden of disclosing behavior, but it does not state whether this tool creates a new material, modifies an existing one, assigns it to an object, or overwrites settings. It mentions EEVEE specificity and parameter effects, but key side effects are omitted for what is clearly a mutating operation.

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

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

The description is compact and well-organized: purpose first, then use cases, then a clean argument list. Every sentence earns its place, and the parameter notes are directly useful given the empty schema descriptions.

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 configuration tool with no annotations and no output schema, the description covers purpose, use cases, and parameters well. However, it is not fully complete for an agent deciding whether to call this tool or what side effects to expect; missing details like whether the material must pre-exist or whether it is assigned to selected objects leave meaningful 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, and it does: all four parameters are explained with meaningful guidance, including recommended values like '0.95 = fully glass-like' and '1.52 = standard glass.' The only minor weakness is that 'material_name: Name of the glass material' is somewhat tautological and unclear about existing vs. new materials.

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 job: 'Configure glass/transparent material for EEVEE.' This is a specific verb, resource, and renderer, and the examples (windows, lenses, screens) make the intent unambiguous. It does not explicitly contrast with sibling tools like set_material_property or create_material, but the glass/EEVEE focus is enough to distinguish it.

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 'Works for windows, lenses, screens, bottles, or any transparent surface' gives clear usage context and implies when this tool is appropriate. However, it does not explicitly mention when not to use it or name alternatives such as set_material_property or create_procedural_material, leaving the selection decision somewhat inferential.

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 behavioral burden. It does disclose a useful constraint ('spot_angle ... spot lights only') and implies mutation of an existing light. It does not say whether omitted parameters retain current values or get reset, nor what happens if the named light does not exist.

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

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

The definition is front-loaded with a one-sentence purpose and a clean Args block. Every line adds information; there is no filler, repetition, or unnecessary 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 6-parameter configuration tool with no annotations and no output schema, the description covers parameter semantics well but omits when-to-use routing and the behavior of unspecified parameters. An agent can call it for straightforward cases but cannot tell whether nulls mean 'leave unchanged' or 'reset to default.'

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 parameter list is the primary documentation. It adds real meaning beyond bare names: energy is in watts, color is an [R, G, B] array, and spot_angle is in radians and only applies to spot lights. Some ranges, such as color value bounds, are still unspecified.

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 opening sentence 'Configure an existing light's properties' names a specific action and resource, and the word 'existing' clearly distinguishes it from create_light. It also enumerates the affected properties, leaving no ambiguity about the tool's scope.

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

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

Use is implied by 'existing light': the tool is for modifying lights that already exist, not creating them. However, it never explicitly names alternatives such as create_light or list_lights, nor does it state when to prefer this over related lighting tools like setup_hdri_lighting or setup_studio_lighting.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it 'configures settings' without mentioning whether it mutates the modifier, merges or replaces existing settings, requires the object to be active, or what happens on failure. The lack of any behavioral detail for a mutation tool is a significant gap.

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

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

The description is very short and front-loaded with the purpose, which is structurally efficient. However, brevity here results from under-specification rather than careful trimming—it omits essential context. It's not verbose, but it doesn't earn its place because it fails to inform the agent beyond the bare names.

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 three parameters, a nested dict, no output schema, and no annotations, the description is inadequate. It doesn't explain the meaning of 'settings', what values are accepted, whether the modifier must exist, or how the tool behaves in edge cases. An agent would have to guess or experiment to use it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It restates the three parameter names and gives a one-line type for settings ('Dict of setting_name: value pairs'), which adds minimal value over the schema. It doesn't explain what object_name refers to (e.g., a scene object), what modifier_name must match, or what setting keys are valid. The description essentially paraphrases the schema without enriching 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?

The description states a clear verb ('configure') and a specific resource ('existing modifier'), which distinguishes it from sibling tools like add_modifier, remove_modifier, or reorder_modifier. It implies the modifier already exists, which is a useful scoping detail. However, it doesn't elaborate on what 'settings' means or how they relate to the modifier, leaving some 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 guidance is given on when to use this tool versus alternatives. It doesn't mention that it should be used after a modifier is added, nor does it reference any sibling tools or conditions that would select this over add_modifier or set_material_property. The agent is left to infer usage from the name and the single sentence.

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 responsibility for behavioral disclosure. It clearly communicates that this tool configures render settings and enumerates the affected fields, but it does not mention side effects like whether a render is triggered, whether previous settings are overwritten, or how engine-specific parameters are ignored.

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 one-sentence summary is front-loaded and the Args list is compact and scannable. Every line adds value, and there is no redundant prose.

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 configuration tool with 7 optional parameters, no annotations, and no output schema, the description is largely self-contained and sufficient for invoking the tool correctly. It is only missing a short usage hint about when to apply these settings and how zero or default values are interpreted.

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 parameter descriptions are essential. The description compensates by explaining every parameter, including enum-like values for engine, explicit values for device, and meanings for samples, denoising, max_bounces, and resolution dimensions.

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: 'Configure render engine, GPU, samples, resolution' and backs it up with a complete parameter list. It clearly identifies this as a render-settings tool, though it does not explicitly differentiate itself from render_preview, render_image, or set_viewport_shading.

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 about when to use this tool versus its render-related siblings. There is no mention of calling this before rendering, nor any indication of which settings apply to which engine beyond the parameter descriptions.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It merely says 'Configure' and lists parameters, but does not state whether sculpt mode is required, how existing brush settings are affected, whether the change is persistent, or what happens if no active sculpt brush 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 compact and well-structured: a decisive lead sentence followed by a concise parameter list. Every line earns its place without redundancy or unnecessary elaboration.

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

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

The description covers the core action and all parameters, but it omits important context such as the need to be in sculpt mode, the effect on an active object, and any behavioral expectations around invalid states. The absence of annotations and output schema makes these gaps more noticeable, though the tool itself is relatively 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?

Schema description coverage is 0%, so the Args block adds meaningful information for all four parameters, including brush name examples, size semantics, and strength range. Some entries like 'auto_masking: Enable auto masking' are close to tautological, but overall it compensates well for the schema's lack of descriptions.

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

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

The opening sentence 'Configure the active sculpt brush' clearly identifies a specific verb and resource. It conveys what the tool does and is distinguishable from broader sculpt tools like enter_sculpt_mode or configure_dyntopo, though it does not explicitly name a sibling to differentiate itself from.

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 use this tool versus alternatives, nor any mention of prerequisites such as being in sculpt mode or having an active sculpt object. The phrase 'active sculpt brush' indirectly implies context, but the description leaves the usage conditions to inference.

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

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

No annotations are provided, so the description bears full responsibility for disclosing side effects. It states the operation (connect) but says nothing about whether an existing connection is replaced, whether multiple wires are allowed, whether sockets must be input/output, or what happens on invalid names. This leaves the agent guessing about mutation behavior.

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

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

The description is compact, with a one-line purpose followed by a clean Args block. It is front-loaded with the core intent and contains no filler. The minimal label expansions are redundant with the schema titles but are still organized and skimmable.

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

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

With five required parameters, zero annotations, no output schema, and 0% schema description coverage, the description needs to provide a complete mental model for a correct call. It does not explain prerequisites (existing node group and nodes), exact socket-name/socket-direction requirements, or error/return behavior, so an agent would likely need trial and error.

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 needed to add real semantics for all five required parameters. It only restates the parameter names with shallow labels ('Source node name', 'Target socket name'), adding almost nothing beyond the schema's own titles. It omits exact name matching rules, socket direction, and value formats.

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

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

The description opens with a specific action ('Connect two nodes') and a concrete resource context ('in a geometry node tree'), which distinguishes it from connect_shader_nodes. It does not restate the tool name and names the key objects involved. Minor gap: it doesn't explicitly say it creates a wire from from_socket to to_socket, but the Args section clarifies source/target.

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 'in a geometry node tree' implies a use context and creates implicit contrast with shader-node wiring. However, there is no explicit guidance about prerequisites (nodes already added, valid group) or when to prefer this over add_geometry_node, connect_shader_nodes, or create_procedural_distribution. The sibling tool names make the distinction inferable, but the description itself doesn't spell it out.

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?

There are no annotations, so the description carries the full burden of disclosing behavior. It only says 'connect', which implies a mutation, but it does not mention whether existing connections are replaced, whether nodes/sockets must already exist, or what happens on invalid socket names. For a mutating graph operation this is a meaningful transparency gap.

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

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

The description is compact and well-structured: one clear purpose sentence followed by a straightforward Args list. Every sentence earns its place, and the action is front-loaded before the parameter details.

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 simple operation, five clearly documented parameters, and no output schema, the description covers the essentials an agent needs to make the call: what the tool does, which material to target, and which nodes/sockets to connect. It does not explain edge cases like overwriting existing links, but that is secondary for a basic connect operation.

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

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

Schema description coverage is 0%, and the description compensates by listing all five parameters with brief meanings: 'Target material', 'Source node name/label', 'Source socket name', 'Target node name/label', and 'Target socket name'. This adds basic semantics beyond the bare schema, though it stays shallow and gives no examples or 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 first sentence states a specific action and resource: 'Connect two shader nodes in a material's node tree.' This clearly distinguishes it from siblings like add_shader_node, set_shader_node_value, and connect_geometry_nodes by specifying both the operation and the domain (shader nodes, material node tree).

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

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

The description provides clear context: this tool connects shader nodes within a material's node tree, which implies it should be used after nodes exist and when a link is needed. It does not explicitly name alternatives or exclusion cases, but the domain restriction to 'shader nodes' and 'material's node tree' is enough to route an agent away from geometry-node or value-setting 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?

With no annotations, the description carries the full burden. It discloses that a new mesh is created (via 'Name for the new mesh'), but does not clarify whether the original curve is preserved, deleted, or hidden, nor what happens on invalid input. This leaves significant behavioral ambiguity.

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

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

The description is extremely concise: a single clear purpose sentence plus a minimal Args block. No wasted words, and the most important information 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?

The tool is simple, but the description lacks clarity on whether conversion is in-place or creates a new object, and does not specify return behavior or prerequisites. Given no annotations and no output schema, a bit more context would make it 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 parameter section is essential. The description explains curve_name as 'Curve to convert' and name as 'Name for the new mesh. Empty = auto', adding practical meaning beyond the bare schema.

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

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

The description states a specific verb and resource: 'Convert a curve object to a mesh.' This clearly identifies the tool's function and differentiates it from more generic conversion tools like convert_object, though it does not explicitly name that sibling.

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

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

No guidance is provided on when to use this tool versus alternatives such as convert_object, nor any prerequisites, exclusions, or expected context. The agent must infer usage from the tool name and brief 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?

With no annotations provided, the description carries the full burden of disclosing side effects. It states that conversion happens but does not say whether the original object is modified or replaced, whether data is preserved, what limitations apply, or what happens on failure. For a mutation-style tool this is a significant transparency gap.

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

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

The description is short, front-loaded with the core purpose, and contains no fluff. The Args block is compact and directly repeats parameter names in a scannable way. It earns a high score for conciseness, though the Args block adds only marginal value over 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 no output schema and no annotations, the description is not complete enough for an agent to understand the full consequences of calling it. It explains what the tool does and what the parameters are, but omits behavioral context such as success/failure behavior, whether the object is replaced, and supported type restrictions. A simple tool should still disclose these basics.

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 the bare schema. It provides minimal meaning for both parameters—'Object name' and 'Target type (MESH, CURVE, SURFACE, etc.)'—but it does not enumerate supported target types, clarify case sensitivity, or explain what values are valid beyond loose examples. It adds only slightly more than the property names and default already provide.

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 converts an object to a different type and gives a concrete example (curve to mesh) plus example target types (MESH, CURVE, SURFACE). It is specific enough to distinguish the generic operation from the more targeted sibling convert_curve_to_mesh, though it does not explicitly name that sibling.

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 about when to use this tool versus alternatives such as convert_curve_to_mesh or other conversion-related tools. The description implies generic conversion use, but it does not state exclusions, prerequisites, or which sibling should be preferred for specific conversions.

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 full burden, but it only says 'Create' without disclosing side effects, what happens on success, whether it adds to the active collection, or any state changes. It doesn't mention if it's destructive or reversible, which is a significant gap for a creation tool.

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

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

The description is extremely concise, with the purpose stated first and an 'Args' section that is directly to the point. No unnecessary words or repetition; it's well-structured for a simple two-parameter tool.

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

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

For a creation tool without annotations or output schema, the description is incomplete. It doesn't explain what an armature is used for, how it integrates with the scene, or what the return value is. It also fails to differentiate from similar object creation tools, leaving the agent without enough context to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It lists 'name' and 'location' with brief explanations ('Armature name', '[x, y, z] position'), which adds minimal meaning over the schema's types and defaults. It doesn't clarify coordinate space, units, or how location is applied, but it does provide basic semantics.

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

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

The description clearly states 'Create a new armature object' with a specific verb and resource. It distinguishes from generic create_object by naming 'armature', and from create_humanoid_rig by being more basic. However, it doesn't explicitly contrast with create_object or mention the rigging context, so it's clear but not fully differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives like create_object or create_humanoid_rig. There is no mention of prerequisites, scene context, or exclusions, leaving the agent to infer when armature creation 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 are absent, so the description carries the full burden of behavioral disclosure. It only says a camera is created with optical settings; it does not mention whether the new camera becomes active, what happens to existing cameras, where it is added, 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 compact and well-organized: one framing sentence followed by a tight argument list. Every line provides useful parameter information and no filler is present.

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

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

All parameters are documented, but the absence of an output schema and annotations means the agent still lacks information about the tool's return value and behavioral side effects. Combined with no usage-vs-sibling guidance, the description is adequate but not complete for confident invocation.

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

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

Schema description coverage is 0%, but the description compensates by explaining all seven parameters, including useful semantic details such as Euler rotation, focal length in mm, and near/far clipping distance. It adds meaning beyond the bare schema titles, though it could go further on units and defaults.

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

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

The description states a clear action and resource: 'Create a camera with optical settings.' It distinguishes its core intent from the sibling configure_camera by using the verb 'create', though it does not explicitly name that sibling.

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

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

No guidance is provided about when to use this tool versus alternatives such as configure_camera, setup_camera_track_to, or set_camera_framing. The implied context is 'when you need a new camera,' but there are no explicit exclusions or sibling comparisons.

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

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

With no annotations, the description carries the full burden of disclosing behavior. It states the create action but does not disclose side effects, error conditions (duplicate names, missing parent), or whether the operation is reversible. The 'empty = root' hint for parent adds some context but not enough for a mutating operation.

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

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

The description is compact and front-loaded with the primary purpose. The Args block is neatly formatted and each sentence contributes. Slightly more detail would be beneficial, but it remains clean and scannable.

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

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

For a simple create operation, the description is minimal but incomplete. It fails to explain the hierarchical relationship implications, duplicate handling, or parent existence rules. Given the lack of an output schema and annotations, more context is needed for correct invocation.

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

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

Schema coverage is 0%, so the description must compensate. It provides basic definitions for both parameters and explains that parent empty means root, which adds meaningful semantics beyond the raw schema. However, it lacks details like name constraints or parent existence requirements.

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 verb 'Create' and the resource 'collection', immediately distinguishing it from sibling tools like delete_collection or move_to_collection. The action is unambiguous and the tool name is not merely repeated.

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

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

No guidance is provided on when to use this tool versus alternatives such as list_collections or create_object. There is no mention of prerequisites (e.g., parent must exist) or scenarios where another tool would be more appropriate.

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